Archiv verlassen und diese Seite im Standarddesign anzeigen : GUI für nodeMCU
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:
34438
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
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++?
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.
achso, zur Webseiten-Gestaltung...!
Das klingt super !! :D
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.
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ß!
Wen der Fortschritt des Projekts interessiert, in meinem Blog berichte ich darüber.
Hier kann man dem folgen: https://www.roboternetz.de/community/entries/486-Browseranwendung-f%C3%BCr-nodeMCU-Webserver
Falls es noch Vorschläge (bezüglich dessen, was man mit der Benutzeroberfläche tun kann / können sollte) oder meinetwegen auch Kritik,
geben sollte, dann bitte gerne hier schreiben!
Ich bin noch nicht sicher, ob ich die Software später mal, zur freien Nutzung, freigeben werde. Das hängt vor allem davon ab,
wie stabil sie in den verschiedenen Browsern ausgeführt wird. Auch Darstellungsprobleme spielen eine Rolle. In der Regel möchte ich
nur äußerlich einwandfreie Sachen weiter geben. Das Feedback dazu spielt am Ende dann auch irgendwo mit in die Entscheidung rein.
MfG
Moppi
Hallo,
ich kann jetzt mehr zu den Möglichkeiten der Benutzeroberfläche sagen,
nachdem ich einiges für die neue Anwendung exportiert und geändert habe.
Ich habe versucht, das Wirrwarr in meinem Kopf zu ordnen und folgend
3 Absätze daraus erstellt.
1) Zurzeit sieht es so aus, dass die gesamte Funktionalität, auf die der Benutzer
Zugriff hat, überwiegend in programminternen Scripten steckt. Dies betrifft
zum Beispiel das Ordnen von Daten (Neuanlegen, Ändern, Löschen, Wiederherstellen).
Dies zählt zu den Möglichkeiten, welche die Benutzeroberfläche ursprünglich bietet,
in deren Exportierung ich mich noch befinde. Ebenso die Funktionserweiterung über
eine relativ einfache Programmierung. Ich müsste diese entfernen oder für
die normale Nutzung unsichtbar machen.
2) Was ich zunächst angedacht habe, ist die Verwaltung der Stapelverarbeitung,
die ich für Mikrokontroller integriere. Außerdem ist es einfach, über
den Webserver auf einem nodeMCU, an Variablen zu gelangen, die den Betrieb
einer Maschine beeinflussen (Setup-Daten). Über die Benutzeroberfläche
könnten diese ausgelesen, geändert und zurückgeschrieben werden.
Auch Sensor- und sonstige Daten sollen über den Webserver auf dem nodeMCU
abgefragt werden und in der Benutzeroberfläche dargestellt werden können.
Eine Debuggerausgabe für die Stapelverarbeitung der µC soll möglich sein.
Weitere Möglichkeiten sind, durch die freie Programmierung, denkbar.
3) Ein Autostartobjekt will ich dem Nutzer zur Verfügung stellen, um dort eigene
Script-Objekte abzulegen, mit denen die Funktionalität der Oberfläche für
eigene Bedürfnisse erweitert werden kann.
Ein Objekt für Systemskripte, welche die zukünftige Funktionalität abbilden,
also all das, was ich unter Absatz 2 erwähnte.
Beide Objekte sollen ausgeblendet werden. Bei Bedarf könnte man sie sichtbar
machen. Das Systemobjekt könnte auch immer unsichtbar bleiben, so dass der Nutzer
auf die damit verknüpften Scripte keinen unmittelbaren Zugriff hat.
Um die Funktionalität der bisher exportierten Scripte zu sichern, muss ich noch
eine Menge überprüfen, ergänzen und ändern. Das ist noch einiges an Arbeit,
bevor ich mit der zweckbestimmten Programmierung (s. Absatz 2) beginnen kann.
MfG
Hallo,
Da ich nicht weiß, wie abstrakt und greifbar das alles für Andere ist, folgend eine Übersicht,
was an Möglichkeiten vorhanden ist und was (aus meiner Sicht) beibehalten werden sollte.
Dazu muss man wissen, dass unter der Benutzeroberfläche ein Script-Interpreter sein Werk tut.
Ich hatte dies an anderen Stellen schon angemerkt. Es können vom Benutzer Scripte erstellt werden
(Codezeilen eingefügt werden), um das Verhalten der Oberfläche zu steuern / zu beeinflussen / zu ändern.
Es können damit auch komplexe Programmabläufe erstellt werden.
Hier eine Aufzählung:
- einen Autostart (-Ordner, eigentlich nur ein Objekt), um Benutzer-Script-Code automatisch aufzurufen
- neue Projektumgebungen erstellen, um Projekte zu trennen und die Arbeit mit der Benutzeroberfläche zu beschleunigen
- hinzugügen von Ordnungsobjekten, Subobjekten, Codeobjekten, Textanmerkungen und Vorlagen
- Verwaltung und Erstellen von Ojekten für Templates, in Textform und deren Verarbeitung
- Erstellen von Regel-Clustern, um das Abarbeiten von Bedingungen und bedingungsabhängigen Zuweisungen / Änderungen zu beschleunigen
- Ausgabe (z.B. in Listen und Textfelder) um Information anzuzeigen
- Datenübertragung zwischen Webserver und Benutzeroberfläche
- HTML-Scripte in die Benutzeroberfläche (als Fenster) einbinden / darstellen, für neue Schnittstellen zum Benutzer (Listen, Textfelder, Buttons)
Nun kommt es darauf an, etwas daraus zu machen.
Ich werde natürlich weiter dran arbeiten, auch wenn keine Vorschläge, für oder wider irgendwelcher Sachen, hier eintreffen.
MfG
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/attachment.php?attachmentid=34438&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?
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:
https://www.roboternetz.de/community/attachment.php?attachmentid=35256&d=1603039670
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
ist sehr schwer zu lesen, wenn's so umbrochen ist, wie es jetzt ist. Wie machst du das? Auch bei deinem blog, da vergeht einem die lust das zu lesen...
Sind die Zeilen jetzt zu kurz?
Vor einiger Zeit hatte jemand dieses Problem, der Lesbarkeit, mit nicht umgebrochenen Zeilen. Ich meine Rabenauge war es. Irgendwann ist mir das auch mal aufgefallen, dass die Zeilen teils sehr lang sind und es dann nicht so gut zu lesen ist. Deshalb breche ich die Zeilen früher um.
Aber das mit der Lesbarkeit ist mit der Groß-/Kleinschreibung auch nicht besser, wenn die weg gelassen wird und alles überwiegend klein geschrieben wird.
Gruß
machst du den umbruch manuell? wozu denn das?
Fragen zur Textformatierung bitte im Forum Offtopic-und-Community-Tratsch (https://www.roboternetz.de/community/forums/44-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
es waren ja keine fragen zur formatierung, nur ein bischen meckern über unangenehme lesbarkeit. Ist ja wieder ok...
das mit der kleinschreibung (nur eigennamen sind gross), da wirst mich nicht mehr ändern können, dafür mache ich das schon viel zu lange :-)
der letzter beitrag sprach von buttons und textfeldern, die individuell anpassbar wären. Ist das für eine bidirektionale kommunikation mit dem roboter nutzbar?
was ich in Deinem ersten bild gut fand - zumindest war es meine annahme - das war die gleichzeitige darstellung eines programmablaufplanes und des programmcodes (wenn ich es richtig verstanden habe?). Wenn sich das auch noch wechselseitig automatisch anpassen würde...
der letzter beitrag sprach von buttons und textfeldern, die individuell anpassbar wären. Ist das für eine bidirektionale kommunikation mit dem roboter nutzbar?
Ja, zum Beispiel. So wie eigentlich alles an dem Programm darauf abzielt.
darstellung eines programmablaufplanes und des programmcodes (wenn ich es richtig verstanden habe?)
Ein Programmablaufplan hat nicht direkt was mit Code zu tun. Der Teil der Ablaufpläne war eigenständig. Dort habe ich mich darin geübt, wie man so einen PAP umsetzen kann. Weil ich so was spannend finde. Da muss man auch die Verbindungen verfolgen und draus Verknüpfungen zwischen Objekten erstellen. Das funktionierte schon so weit, dass der PAP ausgeführt werden kann (auch mit Unterprogrammen, die verknüpft sind), allein aufgrund der Funktion der einzelnen PAP-Symbole, als eine Art Pseudocode. Auch Verknüpfungsfehler im PAP werden erkannt und aufgezeigt. Du hast angenommen, dass irgendein Programmcode, in C oder JavaScript evtl., raus kommt. Ja eigentlich sollte das so sein, tut es aber bisher noch nicht. Mit so einem PAP kann man auch einfach Programmodule untereinander verbinden.
Angefangen hatte ich damit, PAP-Fenster in die Benutzeroberfläche einzubauen. Ursprünglich wollte ich die Oberfläche nach einer anderen Logik gestalten, als jetzt. Jetzt passt es zurzeit nicht ins Konzept.
Damit man sich die Funktion etwas vorstellen kann und wie alles aufgebaut ist, habe ich hier mal ein Bildausschnitt aus einer anderen Anwendung, weil dort Programmteile enthalten sind, die es jetzt hier noch nicht gibt.
https://www.roboternetz.de/community/attachment.php?attachmentid=35260&d=1603208886
Die Programmstapel sind hier andere, als ich sie jetzt dann einbaue. UNd es geht nicht um die Steuerung eines Roboters, sondern eines Avatars. Ist aber egal, man kann auch annehmen, der Roboter hieße Lea...
An manchen Begriffen muss man sich nicht stören, ist alles experimentell.
MfG
soll das so was ähnliches wie Scratch sein? Ich kapier es aber wohl noch nicht, für was das gut sein soll...:confused:
Ich habe etwa 2008 meine ersten Schritte dazu gemacht. Dann hat es mehrere Versionen durchlaufen. Von 2012 bis 2018 habe ich dann dieses System entworfen und umgesetzt. Ich weiß auch nicht, was es ist. Ich wusste auch nie, was irgendwann dabei heraus kommt. Ich hatte mal ein Ziel, Webseiten damit zu erstellen, das dann aber anderen Ideen mehr und mehr gewichen ist, als mir aufgefallen ist, dass ich weit mehr damit machen könnte. Während dieser Zeit habe ich mich abgeschottet, um unbeeinflusst zu sein. Darum weiß nicht, mit was man "es" vergleichen könnte. :) Es ist auch unheimlich mächtig und komplex, wenn ich bedenke, was man damit alles tun kann. Aber der ganze Funktionsumfang soll hier nicht verwendet werden, eher eine etwas abgespeckte und inhaltlich veränderte Version.
Was man sieht, sind die Ordungsobjekte oder Ordnerobjekte, damit die Informationen etc. irgendwie sortieren kann. Baumstruktur, kennt man. Alles, was darunter steht: links drehen, rechts drehen usw. , sind ausführbare Sachen. Eigentlich ist es ein Multifunktionswerkzeug. Ich habe schon überlegt, ob ich damit nicht auch Hilfeseiten erstelle (an sowas denke ich nicht das erste Mal). Man muss nur den Text entsprechend anlegen.
Ich denke, wenn alles zusammengestellt ist, kann man damit experimentieren. Dafür ist es am Ende jetzt auch gedacht. Wenn man sich damit auseinandersetzt kann man sich nach und nach den vollen Umfang erarbeiten, wenn man es brauchen kann.
Ich schaue mal was Scratch ist....
neee ... hat mit Scratch nichts zu tun, Scratch ist auch unter anderen Gesichtspunkten entwickelt worden.
Man muss betrachten, was ich jetzt brauche. Das ist eine Verwaltungstruktur, wo ich Codebausteine unter einem Dach verwalte, aufbaue, teste und Funktionalität in seiner eigenen Form (als Befehlsstapel) auf einen µC übertragen kann. Außerdem kann ich damit die Kommunikation mit dem Webserver des nodeMCU herstellen. Inwiefern im Detail, das ergibt sich dann demnächst. Heute bin ich so weit gekommen, wie Ausgabebereiche einzufügen, um Daten meines Protype Car II ausgeben zu können. Dann werden wohl die Stapel folgen, die über die Oberfläche aufgebaut werden. Dann sollen die zum nodeMCU übertragen und von dort auch auf die beiden angebundenen ATmega328P verteilt werden. Damit können Aktionen ausgelöst (wie Motor drehen) und Werte ausgelesen werden. Danach könnte man es weiter entwickeln.
Bis jetzt kümmere ich mich noch um die Schnittstellen, z.B. zur Datenausgabe. Es ist noch keine Zeile Code eingeflossen, welche die eigentliche Funktion herstellt. Das werde ich vermutlich alles über genau diese Oberfläche programmieren, jedenfalls will ich mal schauen, ob und wie weit das möglich ist, ich sehe aber keinen Grund, warum nicht. Dann könnte auch jeder alles ändern, oder einfach nur eigene Sachen hinzufügen die er brauchen könnte.
Alles in allem verfolge ich einen modularen Ansatz, auch bei der Hardware, wo eins auf dem andern aufbaut.
Um mal hier im Forum einen Vergleich zu ziehen: Oberallgeier verfolgt auch einen solchen Ansatz, was ich so verfolgt habe. Für viele Funktionen einen eigenen µC, wobei die alle irgendwo zusammenlaufen und verbunden sind. Er schickt dann über die Schnittstellen (meist seriell, wenn ich mich nicht irre - Oberallgeier korrigiere mich!) auch Befehlssequenzen, z.B. um einen Servo zu steuern.
was ist dann daran anders als bei C++ Libs, die ebenfalls Wrapper nutzen für solche komplexe Funktionen wie drehen oder Encoder auslesen etc?
Außerdem ist "GUI" dann auch noch missverständlich - GUI heißt doch nur "Graphical User Interface":
meinst du eine GUI-IDE, mit der man "graphisch programmieren" kann, indem man Widgets auf eine Form zieht (wie bei qt Creator oder Borland Delphi oder C++ Builder)
oder
soll deine GUI eine graphische Schnittstelle für ein fertiges Programm sein, die Messwerte anzeigt (Monitor, Dashboard) und Buttons, mit denen man zusätzlich durch Mausklick Funktionen steuern kann (Remote Control für diverse Aktoren: an, aus, vorwärts, rückwärts, Stopp, Drehen...) ?
Was genau ist bei dir eigentlich "Graphisch"?
GUI ist GUI. Mehr gibt es dazu nicht zu sagen.
was ist dann daran anders als bei C++ Libs
Beides ist nicht miteinander zu vergleichen. Das hier soll eine hardwarenahe Programmiersprache nicht ersetzen. Man kann es aber am ehesten mit irgendeinem Basic vergleichen.
Bei dieser Oberfläche bzw. dem darunter liegenden Programm, geht es vor allem um Abstraktion, ohne auszuschließen, dass man damit aber auch Code ausführen kann.
Die Interface-Funktion (Interface in dem Fall meint den Teil, wo die Baumstruktur abgebildet wird) ist gesamt in einer Art programmiert, die auch verwendet wird, wenn das Interface benutzt wird.
Über das Interface kann man eigentlich auch dessen Funktion ändern. Das Programm kann sich selbst ändern. So, wie das unter DOS möglich war, wo man mit COM-Dateien bspw. den Code der Datei überschreiben konnte.
Die Abstraktion bekommt man auch mit JavaScript hin, C++ oder anderem. Auch mit Assembler oder Maschinencode ist das möglich. Nur gerade bei Letzterem offenbart sich dann, wo die Nachteile liegen. Auch in der Arduino-IDE ist das möglich. Es ist aber unheimlich umständlich, bei größeren Projekten u.U. unübersichtlich und nicht systemunabhängig. Dies hier funktioniert in jedem Webbrowser auf jedem Computer (ob unter Linux, Windows, Mac oder was anderem), der ECMA Script in Version 5 unterstützt (JavaScript). Als ich das grafische Interface noch nicht hatte, habe ich alles in ellenlangen Scripten, per Texteditor, verfasst, was dann irgendwann auch wieder unübersichtlich wurde. Die zugrundeliegende Struktur ist. u.U. nicht ganz einfach zu verstehen und nach längerer Zeit habe auch ich dann immer wieder mal Sachen vergessen (wie Befehle zusammen arbeiteten z.B.). Auch wenn ich eine fast 50-seitige Dokumentation darüber habe. Deswegen habe ich dann diese nächste Ebene eingeführt, die die Handhabung und das Erstellen von Code, den ich eben sonst in Scripten verfasse, vereinfacht und unanfälliger für Fehler macht. Außerdem habe ich direkten Zugang zum ausgeführten, abstrakteren Code, falls irgend etwas nicht funktioniert. Die Arbeit der Programme ist im Detail, Zeile für Zeile und Variable für Variable zu beobachten (auch wenn es dann nat. langsamer ausgeführt wird). Falls mal was nicht funktioniert, kann ich so Fehler in sehr kurzer Zeit finden. Damit steigt die Produktivität.
Ich weiß noch nicht, ob ich die Möglichkeit für dieses Projekt noch zugänglich mache, aber implementiert ist sie: die Programmausführung kann zu jeder Zeit pausiert werden. Stell Dir vergleichsweise vor, MS-Windows hätte einen Pause-Button, den Du betätigen kannst. Man kann hier die gesamte Anwendung im Browser anhalten / einfrieren und später einfach fortsetzen. Bis jetzt sehe ich noch nicht, dass man das hier brauchen könnte.
MfG
PS: ich kann das auch auf einem BueRay-Disk-Player ausführen, auf der Playstation oder dem Fernsehgerät. Also ich kann den nodeMCU - Webserver auch über diese Geräte erreichen und die Benutzeroberfläche dort verwenden.
Hier habe ich die Benutzeroberfläche, vom nodeMCU, auf dem Fernseher im Wohnzimmer, geladen:
https://www.roboternetz.de/community/attachment.php?attachmentid=35262&d=1603277528
sorry, ich verstehe immer noch nicht, was jetzt hier "graphisch" ist...
Es hört sich eher danach an, dass es um eine schriftbasierte Interpreter-Anwendung geht, die in einem Browserfenster läuft.
Worin bzw. wofür (für welche graphischen Funktionen) besteht bei dir das "G" für "Graphic" in "GUI"?
Eine GUI-IDE, in der GUI-Anwendungen programmiert werden können, wäre so etwas (qt creator):
https://github.com/dsyleixa/RaspberryPi/blob/master/qt/quit_wiringPi/screenshot_qt.jpeg
und eine Programm-GUI, für das fertige laufende Programm, so etwas:
https://github.com/dsyleixa/RaspberryPi/blob/master/qt/btns_wiringPi_toolbar_pthread_textedit_ads1115_8/screenshot.jpeg
Auch Visual Studio z.B. wäre eine GUI-IDE, oder Borland C++ Builder.
PS, dein Bild war hier gerade noch unsichtbar:
Oder meinst du damit, dass deine IDE eine Schrift-Programmierung per Java bietet, die aber grafische Design-Elemente (wie den Papierkorb oder die Ordnersymbole) hat?
Wie genau aber schreibt man damit ein Programm?
Dann ist es bei Windows genau so und Deiner Definition von GUI-IDE, die eine Schriftprogrammierung per C/C++ bieten, die aber grafische Design-Elemente (wie den Papierkorb oder die Ordnersymbole) haben.
Grafische Benutzerschnittstelle ist grafische Benutzerschnittstelle. Selbst die Texte, die auf dem Bildschirm erscheinen, sind keine Texte, sondern in einem Grafikmodus der Hardware aus Pixeln zusammengesetzt. Deswegen kann man das auch mit Bildern mischen, Fotos oder Grafiken. In einem reinen Textmodus der Grafikhardware wäre dies nicht möglich. Wenngleich man einfach Scripte verwendet, um die Anordnung aller grafischen Elemente zu beschreiben.
Daher kann ich Dir nicht folgen.
also, wenn ich dich jetzt richtig verstehe, dann kannst du auch grafische Zeiger-Instrumente und und bewegte Grafiken und Mausbuttons zur Steuerung einfügen ins Programm, so wie bei einer Website mit html- oder php oder Javascript?
Und wie wird das ganze programmiert?
- - - Aktualisiert - - -
PS,
wenn die IDE nur zum Aufhübschen grafische Elemente enthält, wie bei der Arduino-IDE oder der Arduino-Web-IDE, und ansonsten lediglich in einem Fenster (MS Windows, XWindows) angezeigt wird, man andererseits aber nur mit Text-Eintippen und nicht mit Grafiken bzw. Widgets und d+d programmieren kann, dann wäre es IMO in der Tat keine GUI-IDE oder ein GUI-Builder, sondern "nur" eine Text-IDE als Fenster-Anwendung.
Alles, was der Webbrowser darstellen kann, kann man damit auch darstellen. Selbst Canvas-Elemente:
Das canvas Element stellt Scripten eine bitmap-basierte Leinwand zur Verfügung, die dann es ermöglicht, einfach und schnell Grafiken und Diagramme zu zeichnen, Bilder anzuordnen, Animationen zu erstellen und vieles mehr.
Quelle: SELFHTML (https://wiki.selfhtml.org/wiki/HTML/Multimedia_und_Grafiken/canvas)
In HTML kannst Du auch Elemente pixelgenau positionieren. Das wende ich an, um Fenster darzustellen, die innerhalb des Browser-Fensters auch verschiebbar sind. Man kann Fotos reinladen etc. pp. Buttons durch Grafiken ersetzen, so ziemlich jedes Eingabeelement in HTML mit Hintergrundgrafiken schmücken oder mit Farbverläufen versehen.
Ohne Texteingaben wirst Du kaum etwas programmieren können, so oder so. Eingaben muss man immer irgendwo tätigen, sinnvoll ist das als Text.
"... mit Grafiken bzw. Widgets und d+d ..."
Hast Du mal nachgedacht, was man damit tun könnte und ob bestimmte Benutzerschnittstellen auch Sinn ergeben?
HTML5 hat dafür ein Drag & Drop - API bekommen ... zum Beispiel...
Bloß schau mal, wann HTML5 offiziell fertig war. Ich habe mit dem Programm Jahre vorher angefangen, weswegen es auch nicht auf diese Mechanismen ausgelegt ist. Zwar sind Icons bei mir vorgesehen gewesen, die man auch hin und her schieben kann und damit theor. auch Drag and Drop umsetzen kann, aber es war nicht notwendig. Was willst Du mit einem Widget denn machen? Wie sollte das sinnvoll eingebettet werden? Welche Funktionen willst Du darüber tätigen?
MfG
Also wenn du sogar Grafiken einbinden kannst: super! Dann ist es tatsächlich ein vollwertiger GUI-Builder!
Klar habe ich mal drüber nachgedacht, was man grafisch machen kann:
z.B. ein Robot-Auto,
steuerbar über einige Mausbuttons oder einen virtuellen Joystick (Richtung, Geschwinidigkeit, stopp)
Anzeige der Geschwindigkeit, Kurs, und der Encoderwerte als Zahlen in Labels
Anzeige der Position im Raum als Grafik, wo im Raum der Robot gerade herumfährt, samt kurzer Spur, wo er vorher war.
Evt. sogar Hindernisse im Raum, die der Robot gefunden hat (SLAM).
Oder eine Wetterstation mit Temperatur, Luftdruck, Sonnenscheindauer, Niederschlagsmenge, Windgeschwindigkeit/-Richtung
Und dann Anzeige aller Werte sowohl mit Zeigern in Rundinstrumenten als auch den Verlauf als Graph in Koordinatensystemen
Ich verstehe allerdings leider immer noch nicht, wie man mit welchen Sprachelementen samt Syntax überhaupt programmiert, denn es ist ja wohl keine Arduino-API-Syntax, die man eintippt, oder?
Vorschläge sind super, werden bei mir immer verarbeitet, sobald mein Gehirn damit Kontakt hatte. Allerdings eben immer die Frage, wann und wie?
... Weg von der grafischen Oberfläche, die "alles"
möglich macht, hin zu dem, was ich zurzeit benötige.
Da stehe ich zurzeit noch.
Da ich jetzt etwas weiter bin, wie das Zusammenspiel mit den µC funktionieren kann, werde ich mein Augenmerk vor allem zunächst darauf legen, Werte von Sensoren usw. in angemessener und brauchbarer Weise auslesen zu können. Ich wollte mögliche lokale Displays, die vorwiegend zu Entwicklungszwecken eingesetzt werden, um solche Werte auszugeben, sparen. Das wird nicht einfach. Wenn ich nur daran denke, Werte die mit dem Rad-Encoder zu tun haben, in Echtzeit darstellbar zu machen. Wenn ich mir anschaue, wie schnell so ein Motor bei meinem Car II drehen kann und dann bedenke, dass diese Geschwindigkeit, in 1/100stel Schritten, kontrolliert wird. Aber ich arbeite an einer Lösung. Am Ende geht es mir darum - zu Entwicklungszwecken - Zusammenhänge besser zu verstehen und dazu möglichst tief in die Hardware reinschauen zu können. Ich muss da an Werte kommen, die sich sinnvoll betrachten lassen. Wäre schon toll, wenn man Abläufe Schritt für Schritt beobachten kann.
mit welchen Sprachelementen samt Syntax:
An der Oberfläche mit einer Script-Syntax, die so sicher wie nur möglich zu handhaben und zu verstehen ist. Deswegen ist jede Befehlszeile gleich aufgebaut. Es folgt immer ein Befehl und dann Parameter. Verschachtelte Blöcke oder kompliziertere Ausdrücke werden vermieden. Das hat nichts mit Java, JavaScript oder sonst irgendwas zu tun, nichts mit C, nicht mit C++, nichts mit Arduino-IDE-C++. Die einzelnen Anweisungszeilen durchlaufen einen Parser, der die entsprechenden Unterprogramme dann mit den entsprechenden Eingabeparametern versorgt und aufruft. Im Browser wird, auf unterster Ebene, alles per JavaScript ausgeführt.
wie sähe denn so etwas in deiner Programmiersprache aus,
für einen Robot mit Differentialantrieb (Tribot mit 2 angetriebenen Rädern plus Stützrad):
100cm mit 100% pwm geradeaus (<<< ziemlich einfach, wenn man Radumfang kennt)
stopp
45° auf der Stelle mit 30% pwm nach links drehen (<<< mittel)
stopp
50 cm mit 60% pwm zurück (<<< einfach )
stopp
vorwärts mit 60%pwm in einem Rechts-Bogen von 90° und Bogen-Radius von 50cm (<<< das ist jetzt schon recht anspruchsvoll)
Anzeige von aktueller Position (x,y in Bezug zu Startpos), Richtung und Geschwindigkeit per Odometrie in 4 Labels auf der Website. (<<< vermutlich nicht extrem schwierig)
Dieses Prinzip mit der Abarbeitung habe ich begonnen nach Arduino zu exportieren. Bloß, aufgrund des Speichermangels, sind dort die Befehle anders. Es gibt auch keine komplexeren Codeblöcke, so, wie für die Browseranwendung. Wie das dann aussehen könnte, wäre als Code so:
die reinen Code-Blöcke, als Hexdarstellung:
[01 20 00 01 08 04 00 01 02 01 02 01 02 02 1 02 00 01 08 04 00]
Mit Erklärung:
Micro Code Stapelverarbeitung
Test für LED an I/O-Pin 4:
Variable#0 laden [1,2,0,HIGH]
Ausgang setzen [8,4,0]
Test über indirekte Variable:
Variable#1 laden [1,2,1,2]
Variable#2 laden [1,2,2,HIGH]
Variable#0 über Variable#1 laden [2,0,1]
Ausgang setzen, Inhalt in Variable#0 [8,4,0]
Die Codes werden übersetzt und dann in der Benutzeroberfläche, als Befehle, in lesbarem Text ausgegeben.
Die Eingabe werde ich etwa so gestalten, dass man die Befehle aus einer Liste auswählen kann.
Es gibt - je nach Funktionsumfang - für jeden µC extra Befehlscodes. Derselbe Befehlscode hat dann auf jedem µC eine andere Bedeutung. Nicht allerdings die Grundfunktionen, wie Inkrementieren, Variablen Werte zuweisen etc.
Da das noch in Entwicklung ist, kann ich Dir noch keinen fertigen Programmablauf zeigen, eben nur das Prinzip und den Aufbau.
Man muss auch immer bedenken, dass die Grundfunktion im µC selbst steckt. Wenn es dort keine Funktion gibt (in Arduino-IDE programmiert), die zum Beispiel eine Kurve fahren kann, wird es dafür auch keinen Befehlscode für die Mini-Stapel geben. Vielleicht ein wenig an die Stapelverarbeitung von IBM-DOS oder MS-DOS denken. Dort ruft man fertige Programme auf und übergibt ihnen Parameter. So soll das Prinzip hier auch sein. Es muss die endgültige Programmierung nicht festgelegt werden. Die Firmware muss nur die Funktionen haben. Später wird der Stapelcode eingespeist und die Funktionen sinnvoll miteinander verknüpft.
danke, das ist jetzt zwar noch sehr theoretisch, aber schon etwas klarer. Bin gespannt, wie dann tatsächlich die Programmierung auf der Web-IDE erfolgt.
Das Prinzip kann man hier schon sehen. Es ändert sich natürlich der Textinhalt. Weil der hat jetzt nichts mit dem Projekt für das nodeMCU zu tun.
https://www.roboternetz.de/community/attachment.php?attachmentid=35267&d=1603363557
Diese Stapel funktionieren jetzt noch für die Benutzeroberfläche als solches. Ich werde diese Funktion aber raus nehmen, weil sie für dieses Projekt jetzt nicht benötigt wird. Statt dessen werde ich das Prinzip der Stapelverwaltung beibehalten, aber die Befehlsauswahl anpassen und am Ende muss das dann noch übersetzt werden, damit reine Codeblöcke für die Ablaufsteuerung auf einem µC entstehen, die übertragen werden können.
MfG
das wäre für mich jetzt noch zu kryptisch und zu unübersichtich, aber mal abwarten... 8)
Ich habe mir Gedanken gemacht, zwei Mal drüber geschlafen und mich für diese Variante entschieden, die Schnittstellen, die meine Firmware hat, in der Benutzeroberfläche abzubilden.
https://www.roboternetz.de/community/attachment.php?attachmentid=35270&d=1603612223
Dazu gehören Variablen, die für Berechnungen usw. benötigt werden. Zusätzliche, spezielle Funktionen (Standardfunktionen, wie Variablen manipulieren, Rechenoperationen, Sprünge usw. müssen nicht extra aufgeführt werden). Die einfache Programmabarbeitung in Blöcken (Stapel). Und das Definieren von speziellen Sprungzielen, hier unter Prozeduren. Eine Prozedur soll hier so definiert werden, dass die Bezeichnung und der Stapel angegeben werden, der zur Ausführung gelangt.
Die einzelnen Geräte ( wie hier der ATmega328 ) bekommen eine eindeutige ID zugewiesen. Normalerweise spielt es keine Rolle, welcher Stapel für welches Gerät entworfen wurde, weil die benötigten Stapel zur Programmabarbeitung untereinander verkettet sind. Daher muss nur ein Stapel zu Anfang exakt zugeordnet und mit einer bestimmten Nummer versehen werden können.
Ich denke, damit habe ich alles abgedeckt, was ich benötige, um die Programmierung eines Gerätes in der Benutzeroberfläche vornehmen zu können.
Die Abbildung dient nur als Beispiel, um den Aufbau zu zeigen.
MfG
Sehr schön, das sieht jetzt schon viel überschtlicher aus!
Was ich immer noch nicht verstehe:
1) Was für ein Gerät baut diese Web-IDE auf einer Website auf?
2) Wie kommuniziert diese Web-IDE mit einem AVR? (mit einem ESP wäre klarer, eben als WiFi oder WEB client)
3) Was ist der Unterschied zwischen Funktionen und Prozeduren?
4) Wie bekommt man die Elemente der Rubriken (Variablen, Prozeduren, Funktionen) in eine Stapelverarbeitung?
per d+d ? Oder wird alles Buchstabe für Buchstabe auf einem PC oder über eine Konsolen-BT-Tastatur etc. eingetippt?
(PS, die Stapel sehen ja doch auch ähnlich aus wie die Blöcke bei Scratch, die man aus einer Auswahl herausziehen und per d+d untereinander gruppieren kann)
Webserver auf einem nodeMCU 1.0, bei mir. Ich habe noch mehrere davon.
Die Webseite ist als Browseranwendung konzipiert und wird vom Webbrowser geladen. Danach ausgeführt, weil die ganze Seite überwiegend aus JavaScript besteht. So wird sie auch im Browser aufgebaut. Dazu habe ich eine Fensterverwaltung in JavaScript gebaut. So wird ein Fenster (eigentlich ein DIV-Container) geöffnet und darin Sachen eingebettet, die zur Laufzeit des JavaScript zusammengesetzt werden. Das Hauptfenster ist 100% breit und 100% hoch, damit füllt es den Webbrowser aus.
Kommuniziert wird ausschließlich mit dem Webserver. Von dort werden die Daten dann verteilt, auf einen AVR. Z.B. über serielle Schnittstelle.
"Variablen" ist ein Organisationsobjekt, weiter nichts. Die Unterobjekte ebenfalls. Sie folgen aber einem bestimmten Aufbau. Zuerst steht dort "variable" dann die Nummer, dann ein aussagekräftiger Text.
Am Ende muss das nicht von der einen Stelle an eine Andere. Es geht nur darum, dass ich das nachher beim Programmieren verwenden kann. Entspricht etwas einem "#define Strecke_1 0" in Arduino-C.
Mit den Funktionen ist es ähnlich. Es gibt einen Text dafür (kann man lesen und verstehen) und darunter noch mindestens ein Objekt "code", dem ein Wert zugeordnet wird. Die Stapelverarbeitung selbst befindet sich in der Firmware für das Gerät. Dort würde dann auf den Code 20 mit "Motoren aus" reagiert, weil entsprechend eine Funktion dafür hinterlegt ist. Wenn ich aber die Funktionen schon alle aufführe, kann ich sie auch in Menüs übernehmen, aus denen ich sie dann als eine Zeile im "Programmcode" übernehmen kann (anklicken und Button [OK] anklicken). Zum Debuggen später ist es auch gut, wenn das dann irgendwo als Klartext erscheint. Ich muss mir nur gründlich überlegen, wie die Informationen strukturiert sein sollen.
Die Stapel sind ja nichts weiter als einfache Programmabläufe. Eben wie in Stapelverarbeitungsdateien unter DOS. Ja, dort wird alles, Zeile für Zeile untereinander angeordnet. Das isz ja meistens so. In PHP, Javascript, Basic. Am ehesten würde ich das mit GW-Basic vergleichen oder BAsic auf dem C64. Dort gibt es einzelne, nummerierte Programmzeilen. Wenn es umgewandelt ist, ist es nur noch ein Zahlenblock, der durch die Firmware (z.B. auf einem AVR) abgearbeitet werden kann.
Um diese Stapel zu "befüllen", gehe ich auf das übergeordnete Objekt und wähle den Menüpunkt "Objekt hinzufügen". Je nach Objekt erhalte ich dann eine unterschiedliche Auswahl, was ich dem Objekt unterordnen kann. Zum Beispiel irgendwelche andern Objekte oder Scriptzeilen, die auch nur Objekte sind.
ok, danke, das klingt dann tatsächlich ähnlich wie Scratch (oder die Lego NXT/EV3-G Blöcke), das sind ja auch Bytecode-Interpreter mit Java o.ä.
Interessantes Konzept!
Eine CPU verwendet ebenso Byte-Code im RAM oder ROM (Maschinensprache), um sämtliche Funktionen, die integriert sind, variabel nutzen zu können. Dieser Ansatz ist sehr gebräuchlich. Bei CNC-Maschinen, 3D-Druckern z.B. nennt es sich G-Code. Verfolgt denselben Zweck: Programmierung / Steuerung, ohne die Firmware zu ändern.
MfG
nein, ich meinte nicht die Maschinensprache, sondern Bytecode, eine Art Zwischencode für virtuelle Maschinen (für Interpreter), wie z.B. von Java verwendet.
Dann weiß ich nicht, worauf Du Dich beziehst.
So etwas wie einen Zwischencode gibt es hier nicht. Es sind genau betrachtet eher Steuercodes.
Es gibt da noch so etwas, was man vielleicht als Zwischencode bezeichnen könnte. Damit habe ich mir die gesamte, kompliziertere Programmierung erleichtert. Ich habe dazu mal ein Auszug aus der Debugger-Ausgabe kopiert.
3: goto:100
100: goto:103:ost=100
101: xfind:roobject:id1:..zu:.id=id
102: goto:4
4: exec:ailib:4
5: goto:19:containerLength>0
19: init:ziel=i1:x-find-scope=i2:scope-frame=i3
20: exec:ailib:0
Hier wird dann noch mehr gemacht, als einfach nur Codes zu lesen und durch ein switch - case - Gebilde zu schicken. Zum Beispiel heraus finden, aus was Teilausdrücke bestehen (wird eine Variable oder ein String verglichen / zugewiesen, oder doch eine Zahl ...). Da werden die Parameter erst noch aufgearbeitet, bevor sie an Funktionen übergeben werden. Bei der Stapelverarbeitung die in einem AVR stattfinden soll, soll nichts weiter geschehen, außer die möglichst zügige Abarbeitung. Die gesamte Aufbereitung von Parametern, Werten usw. wird über die Benutzeroberfläche erledigt.
Vielleicht habe ich Dich auch einfach irgendwie missverstanden .. ?
MfG
naja, "Pinmodus festlegen 0: Output" wird ja nicht Buchstabe für Buchstabe gelesen, einer Syntaxanalyse unterzogen, ausgewertet, und dann übertragen, sondern von deinem Programm per komprimiertem Zwischencode gelesen und dann an die cpu übetragen (IIUC).
Vielleicht stimmt das mit deinem Steuercode überein oder vlt noch einen Schritt tiefer (reine Bytefolgen), jedenfalls ist dein interpretierter Code weder das, was in deiner Web-IDE steht, noch das, was die cpu tatsächlich als Binärcode ausführt:
sondern ein Zwischencode oder Bytecode, den dein Interpreter in deinen Stapeln schrittweise verarbeitet, und ähnlich macht es ja auch Scratch oder NXT-G per VM mit seinen Blöcken.
Guten Morgen!
Sooo... nach vielem Lesen und Überlegen bin ich nun mit neuen Erkenntnissen zurück, bei diesem Thema: Bytecode.
Ich würde sagen: ja, es entsteht ein Bytecode. Das ist völlig richtig; auch "Bytecode-Interpreter".
Den Begriff Zwischencode würde ich hier aber ausklammern. Weil nichts mehr umgewandelt wird. Es ist ein endgültiger (Steuer)Code für den Interpreter. Am Ende wird Maschinencode von der CPU ausgeführt, aber der Code wird nicht in solche übersetzt.
Du beschreibst es mit: "ähnlich macht es ... " schon ganz richtig. Aufsteigend in Abstraktionsebenen werden Verarbeitungsschritte immer ähnlicher. An oberster Stelle können Symbole stehen, die in irgendeiner Weise angeordnet werden. Bei Programmablaufplänen ist es auch so. Interessanter Weise ist damit Inkas Frage nach, bzw. der Hinweis auf die Möglichkeit der Erstellung von PAPs gar nicht so weit weg. Zumindest nicht in der Richtung, was den Bytecode-Interpreter angeht. Ich habe da noch mal in den Quelltext rein geschaut. Die PAP-Geschichte war mal durchaus als Drag and Drop angelegt. Diese Vorgehensweise hat aber nie den Durchbruch gefunden. Statt dessen habe ich mich für eine einfachere Platzierung der Symbole, durch Klicken, entschieden. Ich habe mich damals viel an meinem kleinen Laptop orientiert, der zwar ein Touchpad hat, aber wo ich nie eine Maus verwendet habe, da war es mit Symbolen schieben eher schwierig.
Gruß
- - - Aktualisiert - - -
Ich habe mal einen PAP raus gesucht und eine Bildschirmkopie gemacht, für diese Abbildung hier, der nur klein ist und als Beispiel dient:
https://www.roboternetz.de/community/attachment.php?attachmentid=35272&d=1603696629
Mit den PAPs habe ich damals die Umsetzung der Programmierung, mit Grafiksymbolen, geübt. Um das mal so zu sagen.
Ich wusste nicht, ob und wie man damit würde umgehen können. Fand aber den Ansatz äußerst interessant. So dass ich mich lange Zeit damit beschäftigt habe, bis es schlussendlich auch gebrauchsfertig war. Ich habe dann praktisch erfahren, dass ein PAP einen Ablauf gut beschreiben kann, aber als Grundlage zum Programmieren (als Eingabevariante, statt einem Texteditor) nur bedingt gut geeignet ist. Ich denke, das Handling mit einem Ablaufplan funktioniert erst ab einer bestimmten Abstraktionsebene gut. Ich habe versucht, das auf die Befehlsebene einer Programmiersprache anzuwenden. Das ist ähnlich, wie mit Objekten in den Baumabbildungen. Nur das Objektbäume kompakter und übersichtlicher sind. Bei den Ablaufplänen habe ich vor allem Probleme, mit dem zur Verfügung stehenden Platz, auf dem Bildschirm. Es sind relativ wenige Informationen unterzubringen. Man muss dann sehr oft zwischen PAPs wechseln, was unübersichtlich werden kann, weil ein sehr komplexer Programmablauf als PAP in seiner Gesamtheit nicht sinnvoll abzubilden ist.
Moin!
Kennst du die Programmierumgebung "RoboPro" von Fischertechnik? Die mach es praktisch genau so, mit PAP-Symbolen.
Scratch und Lego-GPLs ähnlich, aber mit abgewandelten PAP-Symbolen.
Die großen Grafik-Symbole snd aber sehr platzraubend und bei komplizierteren Programmen schnell unübersichtlich mit den ganzen Verbindungschnurknäueln, spätestens, wenn sie sich mehrfach überschneiden. Dies auf reinen Script-Text zu reduzieren finde ich weitaus besser.
Interessanter Weise ist damit Inkas Frage nach, bzw. der Hinweis auf die Möglichkeit der Erstellung von PAPs gar nicht so weit weg. Zumindest nicht in der Richtung, was den Bytecode-Interpreter angeht. Ich habe da noch mal in den Quelltext rein geschaut. Die PAP-Geschichte war mal durchaus als Drag and Drop angelegt.
ich hätte es halt interessant gefunden, wenn aufgrund eines PAP zumindest die grobe struktur des codes selbst erzeugt werden würde - oder auch umgekehrt...
nur ein Gestaltungs-Tipp:
ich würde die Ressourcen/Rubriken in eine linke Fenster-Spalte schreiben und den programmierten Programmstapel rechts davon.
Text-Ausgaben des Programms (ähnlich Serial Monitor) und Grafik-Dashboard etc. (ggf wie bei Processing oder per Rundinstrumente oder per Koordinatensysteme oder Turtle-Grafiken) könnten dann in einen 3. Bereich unten drunter angezeigt werden.
Für den Fall, dass es noch nicht bekannt ist, wie der Aufbau der Oberfläche aussieht, folgendes.
Es ist nicht ganz einfach, mit den Darstellungseigenheiten der unterschiedlichen Webbrowser, ein einheitliches Design hinzubekommen, das in jedem Browser zum gewünschten Ergebnis führt. Aus dem Grund bin ich hier schon dazu übergegangen, Frames einzubauen, die dann automatische Bildlaufleisten bekommen, wenn der Inhalt größer ist, als der Bildausschnitt.
https://www.roboternetz.de/community/attachment.php?attachmentid=35273&d=1603720232
9: Ganz oben ist eine Statuszeile, mit zwei Reglern, um die Bereiche, horizontal, in der Breite verstellen zu können. Hier werden auch Informationen in Textform angezeigt.
8: Menüzeile. Ich habe Menüs ganz raus genommen. Weil ich denke, dass die wichtigen Funktionen einfach oben in einer Zeile Platz finden. Darüber lässt sich nun im Grunde die ganze Oberfläche bedienen.
7: Ein weitgehend frei zu gestaltender Bereich. Im Grunde ist nicht festgelegt, wo was stehen soll oder wie etwas angeordnet sein soll. Manchmal muss ich mich - zugunsten der Aufwandsreduzierung, bei der Programmierung - für bestimmte Strukturen entscheiden, damit der Programmcode unter der Oberfläche nicht "explodiert". Hier gibt es nur eine Struktur: Rubriken, die übereinander angeordnet sind und sich aufklappen lassen. Darunter dann, in abgestufter Form, weitere Objekte; durch die Baumstruktur sind Abhängigkeiten zu erkennen, ein Zweig wächst von links nach rechts. Wie viele Objekte einander untergeordnet sind, ist nicht festgelegt. Die Hauptobjekte sind ganz links angeordnet, eine Art Verzeichnis. Es lassen sich neue "Ordner" hinzufügen, die dann eine neue Umgebung abbilden. Alles in der Benutzeroberfläche folgt einem Sandbox-Prinzip. Auch die unterschiedlichen Bibliotheken, die JavaScript beinhalten. Jede Sandbox hat ihre Objekte. Code der Sandboxen kann nebeneinander ablaufen und wird durch übergeordnete Variablen und Mechanismen synchronisiert. Es existiert aber nur ein gemeinsames Objekt, für die HTML-Darstellung. Alle Objekte, die der Darstellung dienen, sind hier untergeordnet. Aus jeder Sandbox kann darauf zugegriffen werden. Was hier in diesem Bereich, Nr. 7, zu sehen ist, ist ein Frame im Browser, mit einer HTML-Seite. Alle Knoten-Objekte sind in einer Seite abgebildet und stellen eine Struktur dar, die einem bestimmten Aufbau folgt. Teile des Aufbaus werden ausgeblendet, damit sind manche Zweige nicht sichtbar, aber jeder Zeit vorhanden. Die gesamte Baumstruktur ist also zurzeit eine Einheit.
5: Zu jedem Objekt im Baum gibt es eine Beschreibung oder Erläuterung (irgendeinen erklärenden Text), der wird hier angezeigt.
6: Die Ausgabe für Debugger etc. In etwa das, was in der Arduino-IDE das serielle Terminal ist. Bloß gibt es hier bisher keine Möglichkeit der Eingabe. Es ist ein reiner Ausgabebereich.
1 bis 4: Weitere Anzeigebereiche. Für Ausgaben von unterschiedlichen Werten gedacht, die man irgendwie aus der Hardware geliefert bekommt. Bereich Nr. 1 könnte Werte von Encoder#1 anzeigen; Bereich Nr. 2 Werte vom ADC und die andern beiden Bereiche andere Sachen. Aus diesen vier Bereichen könnten auch sechs werden. Ich bin mir aber nicht sicher, ob das sinnvoll wäre.
Die Bereiche 7 und 6 sind über Regler in der Breite verstellbar, 1 bis 4 passen sich in der Breite an, damit insgesamt alles in das Browserfenster passt.
Die Informationen, die vertikal dargestellt werden können, verringern sich mit der Höhe des Browserfensters. Ebenso verhält es sich mit der Breite (hier können dann aber, wie beschrieben, die Bereiche etwas angepasst werden).
Werden die Bereiche in der Vertikalen kleiner, muss mehr gescrollt werden, deshalb versuche ich, diese möglichst groß zu halten. In der Horizontalen habe ich mehr Spielraum, auch weil Bildschirme heute vom Seitenverhältnis so angelegt sind.
Was noch nicht zu sehen ist, befindet sich zwischen Bereich 7 und 6. Dort ist noch ein Bereich, zurzeit ausgeblendet, wo zusätzliche Elemente untergebracht werden können. Ein Bereich, der frei zu gestalten sein sollte, also keinen festen Inhalt hat. Ich glaube, damit bin ich ziemlich am Ende angelangt, was auf einen Bildschirm passt.
Gruß
Moppi
- - - Aktualisiert - - -
Ich stelle hier mal die Frage, ob der Thread geschlossen werden kann? Ich tue mich mit der Abgrenzung zu abgeschlossenen oder fast abgeschlossenen Projekten etwas schwer.
Vielleicht ein Moderator-Kommentar dazu?
Ich stelle hier mal die Frage, ob der Thread geschlossen werden kann?
wieso schließen? willst du keine Fragen beantworten und keine Kommentare zulassen? (wenn das tatsächlich so ist, warum stellst du es dann hier im Forum vor?)
warum stellst du es dann hier im Forum vor? im gegensatz z.b. zum "rumgucker" der nur schlaue sprüche hatte - bis er dann nun weg war... ich denke es gibt foren, wo das interesse an sowas grösser ist...
wieso schließen? willst du keine Fragen beantworten und keine Kommentare zulassen? (wenn das tatsächlich so ist, warum stellst du es dann hier im Forum vor?)
Weil es hier unter der Rubrik: Vorstellung zu geplanten Projekten/Bots steht. Da steht ausdrücklich, dass hier keine fertigen oder halbfertigen Projekte eingestellt werden sollen. Dafür gibt es eine eigene Rubrik. :)
Daran will ich mich nur halten, weiter nichts. Ich tu mich aber damit schwer. Weil ein Projekt hat irgendwann einen Anfang und wann es ist es dann fertig oder fast fertig? Ich hätte aber gerne erst eine Einschätzung von einem Moderator dazu, bevor ich dasselbe Projekt nochmals in der anderen Rubrik einstelle.
Gruß
ach so.... ;-)
aber dann können es die Mods auf Wunsch ganz einfach verschieben in eine andere Rubrik/Unterforum.
Dann bleibt es hier. Wenn es dann, inklusive der Hardware, so weit funktionstüchtig ist (richtig fertig in dem Sinn wird mein Car II, dass so flexibel ist, vermutlich sowieso nie), dann stelle ich das evtl. noch mal in der andern Rubrik vor.
Mich interessieren noch folgende Dinge:
1. Wie findet Ihr die Sache, dass die Benutzeroberfläche durch eigene Programmierung funktionell geändert bzw. erweitert werden kann?
Normal wird so etwas ja gar nicht angeboten. Die Funktion steht per Programmcode irgendwann fest und dann bleibt die so, bis die nächste Version erscheint.
2. Ist das Konzept verständlich oder schwer nachzuvollziehen (ich hoffe, dass es möglichst selbsterklärend ist)?
Was die Aufteilung der Oberfläche im Fenster angeht, hatte ich auch so eine ähnliche Idee, wie links ein Verzeichnis, rechts dessen Inhalt und unten drunter evtl. sowas wie einen Serial-Monitor. Ich fand aber so eine Aufteilung nicht so sehr praktisch, angesichts der Sachen, die ich alle unterbringen wollte und auch technisch umsetzen muss.
MfG
1. Wie findet Ihr die Sache, dass die Benutzeroberfläche durch eigene Programmierung funktionell geändert bzw. erweitert werden kann?
Normal wird so etwas ja gar nicht angeboten. Die Funktion steht per Programmcode irgendwann fest und dann bleibt die so, bis die nächste Version erscheint.
diese möglichkeit ist interessant, wenn das auf einer ähnlichen art und weise realisiert wird wie z.b. bei der app "bluetooth electronics" von keuwlsoft. Drag und drop von symbolen, die auf eine einfache art und weise mit befehlen belegt werden könne. Also kein code schreiben!
2. Ist das Konzept verständlich oder schwer nachzuvollziehen (ich hoffe, dass es möglichst selbsterklärend ist)?
Was die Aufteilung der Oberfläche im Fenster angeht, hatte ich auch so eine ähnliche Idee, wie links ein Verzeichnis, rechts dessen Inhalt und unten drunter evtl. sowas wie einen Serial-Monitor. Ich fand aber so eine Aufteilung nicht so sehr praktisch, angesichts der Sachen, die ich alle unterbringen wollte und auch technisch umsetzen muss.
die intuitive bedienung ist schwierig umzusetzen, serial monitor wäre gut...
Drag und drop von symbolen, die auf eine einfache art und weise mit befehlen belegt werden könne. Also kein code schreiben!
Den kompletten Code für einen Roboter schreiben, ohne eine Zeile Code einzugeben? - Ja.. ich denke, das wird machbar sein.
Es ist eine Abstraktionsstufe, die weit, weit über dem liegt, was zurzeit vorhanden ist. Da es aber durch den Aufbau, betrachtet man die theoretischen Möglichkeiten, keine "sichtbare" Abstraktionsgrenze nach oben gibt, kann ich mir das zumindest vorstellen. Da aber irgendwie immer Code ausprobiert werden muss, allein schon während der Entwicklung irgendeines neuen Moduls für Arduino o.ä., wird immer jemand irgendwie, irgendwo Code schreiben müssen. Deswegen mache ich mir zurzeit Gedanken über das Machbare, das aus dem Nutzbaren resultiert. Muss mich ja irgendwie vorarbeiten.
serial monitor wäre gut...
Wenn die serielle Schnittstelle nicht anders genutzt würde. Diese Option wird über den Webserver abgedeckt. Was sonst über "Serial.print" ausgegeben wird, wird über den Webserver verschickt. Bei mir sind das immer irgendwelche Daten, die ich sehen möchte. Welche Informationen dies sein werden, liegt nicht an der Benutzeroberfläche, sondern muss irgendwo im Programm (Software im Gerät) festgelegt werden. Wobei ich schon eine Vorstellung habe, wie man alle möglichen Daten irgendwo herausziehen kann. Da habe ich mich aber noch nicht festgelegt.
Demnächst lege ich Webserver und Bytecode-Interpreter für meinen ESP-12E zusammen. Hey, dann findet ja eine Hochzeit statt! \\:D/ Nachdem ich das Ereignis dann gebührend gefeiert ( begossen? ) ;) habe, kann ich die Verarbeitung mittels des Interpreters ausprobieren. Dann verschmilzt die Funktionalität der Oberfläche mit der des Bytecode-Interpreters, über den Webserver. Dann werden die Fragen interessant: wie komme ich an Daten der Hardware, wie übertrage ich sie genau und wo werden sie genau ausgegeben / angezeigt (und wie)?
So weit...
MfG
Den kompletten Code für einen Roboter schreiben, ohne eine Zeile Code einzugeben? - Ja.. ich denke, das wird machbar sein.
so war das nicht gemeint. Natürlich muss für den roboter auch der code geschrieben werden, der dort läuft. Mir ging es darum, dass beim anpassen der webseite, der icons, nicht ein komplizierte code vom anwender notwendig ist, sondern meinetwegen ein paar auswahlmöglichkeiten, die er dort einzustellen hat um bestimmte dinge abzufragen, oder in der software am roboter abzuändern...
Gut, dann glaub ich, dass ich es jetzt verstanden habe. Das wäre natürlich auch eine Option. Muss aber zusätzlich eingebaut werden. Ich denke, wenn alles fertig ist.
Zu dem, was ich meinte: kennst Du Visual Basic, inka? Dort kannst Du Code schreiben, Buttons positionieren und Textfelder. So ähnlich ist das bei der Scriptsprache für die Oberfläche auch machbar. Wäre aber zu programmieren, mittels Befehlszeilen (Reaktion auf bestimmte Buttons usw.). Das war so eine Idee, die ich als nützliche Zugabe sehen würde. So für die Leute, die eine zusätzliche Funktion vermissen und die sich aber u.U. einfach nachrüsten ließe. Deshalb lasse ich das mal so, wie angedacht. Das Andere müsste man dann oben drauf setzen, evtl. ein extra Fenster dafür machen.
Einen Teil der Funktionalität habe ich schon selbst mit der Oberfläche nachgerüstet, hier ein Auszug eines Beispiels:
https://www.roboternetz.de/community/attachment.php?attachmentid=35303&d=1604594402
Gute Übung für mich, bislang habe ich das ja vornehmlich entwickelt. Jetzt kann ich Ungereimtheiten oder Schwachstellen erkennen und (hoffentlich) noch beseitigen. Die ein oder andere kleine Macke ist ja immer irgendwo, bei umfangreicheren Projekten. Den Rest der Funktionen, die ich für mein Pro Car II - Projekt noch benötige, wie eben Variablen von den AVRs lesen oder, oder, oder ... hoffe ich auch noch auf diesem Weg zu implementieren.
was würdest du von einem video halten wo du (den stand heute) die oberfläche zeigst, mit den möglichkeiten die man da hat und das im video erklärst? Es ist sonst sehr schwer vorstellbar was du da eigentlich entwickelst und machst?
Ja, das sollte so sein. Ich wollte ein Tutorial erstellen. Vielleicht sogar mehrere. Aber dafür brauche ich wohl eine zweite Cam und eine neuere Videoschnittsoftware. Wenn das Pro Car II eingebunden (oder angebunden) ist, wollte ich das gesamte Tutorial darauf aufbauen. Evtl. füge ich sogar Bilder vom Projekt hier und da, in der Oberfläche, ein. Ich könnte aber auch ein Tutorial für die Oberfläche entwerfen.
Eine Beschreibung der Befehle führe ich dauernd fort. Zwischenzeitlich gab es das - für mich - auch mal in Papierform, als Broschüre:
https://www.roboternetz.de/community/attachment.php?attachmentid=35304&d=1604596262
Einzelausgabe ... handgebunden .... :)
Sollte es mal benötigt werden, kann ich das so direkt in die Druckerei geben.
Kurzes Update hier:
Bytecode-Interpreter läuft jetzt einwandfrei. Ebenso die Dateiverwaltung.
Der Quellcode für das nodeMCU ist etwas unübersichtlich inzwischen: Webserver, Serial, I2C, Stapel(Bytecode)verarbeitung und der Hauptsketch. Und das alles muss koordiniert werden.
Bis sich das so sortiert hat und nach und nach funktioniert, war es ein ganzes Stück Arbeit, mit zigmal AVR und nodeMCU ein/ausstecken und am Ende doch noch einen externen Aufbau benötigt, um die Fehler endgültig zu finden. Um so mehr Sachen hinzukommen, die zuverlässig funktionieren, desto schneller geht es dann voran. Immerhin kann ich jetzt schon Stapel nicht nur in der Benutzeroberfläche anlegen, sondern sie auch in korrekten Bytecode umwandeln, an den Webserver zum Speichern schicken, die Daten in der Oberfläche wieder vom Server lesen (Kontrolle ist immer gut), die Blöcke zum AVR übertragen (I2C funktioniert schon , seriell per UART folgt), die Blöcke auf dem AVR ausführen und auf dem nodeMCU ebenfalls (das hat auch den Interpreter). Als nächstes könnte ich Debugging-Daten übertragen, um die Datenverarbeitung des Interpreters sichtbar zu machen und die Programmabarbeitung zu verfolgen (hilft oft irgendwie). Kommt so langsam eins zum andern.
MfG
Hallo,
der Vollständigkeit halber und weil ich keinen neuen Blog-Eintrag erstelle (sondern an meine Einträge Kommentare anfüge), hier folgende Information.
Es gibt einen ersten Zwischenstand, des Projektes, mit dem ich jetzt schon eine gute Grundlage für weitere Aktionen für mein Testprojekt geschaffen habe. Nachzulesen in meinem Blogeintrag hier (https://www.roboternetz.de/community/entries/486-Browseranwendung-f%C3%BCr-nodeMCU-Webserver), am Ende.
MfG
Hallo zusammen!
Also eigentlich wollte ich hier ein Video einstellen. Da kam ja schon mal die Sache mit dem Tutorial auf.
Jetzt habe ich mich damit beschäftigt und bin auf verschiedenste Probleme gestoßen:
Selbst eine kurze Einführung ist schwer für mich in ca. 10 bis 15min zu verpacken.
Ich habe ein erstes Video aufgezeichnet, das mir von der Erklärung her am besten gefiel. Zeit: 30min. Gut, das hätte ich kürzer machen können, hätte ich vorher einen Plan gemacht, an dem ich mich lang hangele. Aber das ist nicht so mein Ding, ich gehe das lieber so durch, wie es mir gerade einfällt.
Nächster Punkt, die Technik. Da habe ich ein kleines Ansteckmikrofon, am PC angeschlossen. Rauscht, wie wenn ich am Wasser irgendwo stehe. Mit Rauschfilterung wird es schwer verständlich, aber zumindest stört das Rauschen dann nicht. Ton daher eigentlich sehr schlecht. Ich habe bis jetzt kein Tool gefunden, wo ich die Tonspur extra speichern könnte. Nachbearbeiten könnte ich die, dafür habe ich Software.
Dann habe ich mir am Ende, nach ein paar Stunden probieren, das Video nochmal angeschaut, diese 30min. Dann habe ich gelesen, was ich hier in diesem Thread oder in meinem Blog schon geschrieben habe. Ergebnis: es gibt keinen Unterschied, außer dem, dass ich beim Video ein Bild habe, wo ich das mit dem Mauszeiger etwas "lebendig" gestalten kann, weil ich auf Dinge zeigen oder auch mehrfach anzeigen und ausblenden kann. Das Videomaterial ist auch nicht perfekt, weil die Software zur Aufzeichnung Listen aus dem Webbrowser nicht mit aufzeichnet. Wenn ich also was zu einer geöffneten Drop-Down-Liste erzähle, sieht man die Liste nicht.
Deshalb frage ich mich, für wie wichtig Erklärvideos gehalten werden und warum? Ich meine, vor Youtube hatten wir so was eigentlich gar nicht. Und auch die meisten Projekte hier, enthalten seltenst ein ordentliches Erklärvideo, ist mir jedenfalls nicht über den Weg gelaufen. Oder sie sind so rar, dass sie bei mir nicht hängen geblieben sind.
Am Ende steht auch die Hürde, dass ich keine Profi-Software dafür habe, so dass das Ergebnis auch entsprechend sehenswert wäre.
Gruß
Moppi
ein video als erklärung für eine software ist schwierig, taugt eigentlich nur als ergänzung zum geschriebenen manual was. ganz was anderes ist eine anleitung zum montieren von baugruppen, wie das hier (https://youtu.be/ceHsL6w6WVk), was ich für meinen damals 10jährigen enkel aufgenommen hab. Hat gut funktioniert, er hat es danach in 650km entfernung nachbauen können :-)
Aber wie gesagt, software in einem video zu erklären ist sicher nicht einfach...
Sag mal, Moppi, kann man mit der formatierung deines blogs wirklich nix machen? Das ist sehr schwer zu lesen!
Nein, was soll ich da machen, mit der Formatierung? Ich hatte bis jetzt keine Rückmeldung wie es am besten wäre. Ich gucke mir alles auf dem PC an, da ist es eher praktisch, wenn die Zeilen kürzer sind (etwa Pi mal Daumen eine Zeichenzahl pro Zeile, die einer Buchzeile gleich kommt). Daher weiß ich nicht, was ich ändern soll. Zum Ändern müsste ich alle Beiträge nochmal editieren.
Schöner wäre es, wenn die Forensoftware das machen würde, irgendwie. Auf Wunsch des Users, der sich das anschaut, könnte man die einfachen Zeilenumbrüche durch ein Leerzeichen ersetzen (also jedes erstes "<BR>"). Dann bekäme man lange Zeilen und keine Zwischenabsätze. Aber das ist das mit der Forensoftware ändern .... (habe gerade mal im Seiteneditor geschaut, die Forensoftware macht tatsächlich bei Zeilenumbrüchen "<br>")
MfG
Searcher
05.12.2020, 15:30
Deshalb frage ich mich, für wie wichtig Erklärvideos gehalten werden und warum?
Vergleichbar wäre die Beschreibung einer Schaltung ohne Schaltbild nur mit Text mit großer Wahrscheinlichkeit mißverständlich. Bei Erklärvideos muß man nicht so viel Wert auf haargenaue Beschreibung legen; man wird dann ja von Bildern/Video unterstützt.
Nachfragen wären dann vielleicht vermieden.
Gruß
Searcher
Nein, was soll ich da machen, mit der Formatierung? Ich hatte bis jetzt keine Rückmeldung wie es am besten wäre.
mir ist es neu, dass man sich als user um die zeilenlänge kümmern muss? bei forumbeiträgen passiert das formatieren automatisch, beim RN-wissen musste ich mich damals beim artikel zwar um einiges kümmern, aber nicht um die zeilenumbrüche!
so sieht die formatierung bei dir aus:
35341
und das kommt mit sicherheit dadurch, dass du die zeilenlänge irgendwie manuell bestimmst.
Bei mir ist die Formatierung nicht zu sehen. Und Bei Dir auch nicht.
Was Du meinst, ist, dass Zeilen umgebrochen werden, wenn die Ausgabe im Browser nicht breit genug ist. Das ist beim HTML-Seiten normal. Der Browser bricht die Zeilen selbst zusätzlich um, ist ein Zeilenumbruch sowieso vorhanden, dann stellt der Browser den auch noch dar. Dadurch kommt es zu diesem unglücklichen Erscheinungsbild. Ist auch u.U. ein Problem beim Webdesign. Entgehen kann man dem nur, wenn man Text am Stück schreibt, ohne Absätze. Absätze gehören aber zum guten Ton, wenn man was schreibt, weil sie den Text sinnvoll gliedern. Also mache ich einen ENTER an meinem Zeilenende und beim Absatz mache ich zwei ENTER hintereinander. Da ich aber eher lange Zeilen nicht mag und daher vermeide (indem ich dann an passender Stelle mit ENTER die Zeile umbreche), sind die Worte pro Zeile dann auch weniger. Wenn Du die Browserausgabe noch schmaler machst, indem Du den Browser mit der Maus weiter zusammenschiebst, bleibt irgendwann nur noch ein Wort pro Zeile stehen. Dasselbe könnte ich erreichen, indem ich nach jedem Wort ENTER drücke und eine neue Textzeile beginne (ist wenig sinnvoll).
und das kommt mit sicherheit dadurch, dass du die zeilenlänge irgendwie manuell bestimmst.
Das kommt durch den zu schmalen Ausgabebereich im Webbrowser. Dasselbe passiert, wenn der Inhalt im Browserfenster vergrößert wird. Bei mir ist das STRG und "+". Bei 200% Skalierungsfaktor wird der Text auch bei mir so riesig, dass die Zeilen mittendrin umgebrochen werden. Dagegen hilft: den Skalierungsfaktor wieder verringern. Oder einen größeren Bildschirm verwenden.
MfG
PS: Um das mit dem "<BR>" nochmal klar zu machen, so wird das von der Forensoftware an den Browser übermittelt:
<blockquote class="posttext restore">
Ich bin mit meinem 3D-Drucker noch nicht ganz im Reinen, deshalb habe ich den zunächst <br>
mit einem All Metal Hotend modifiziert, bei dem der PTFE-Schlauch nicht mehr bis an <br>
die Düse heranreicht (Ender 3 und Co.).<br>
<br>
Ich habe ein Chassis konzipiert, das nun ca. 28cm im Durchmesser groß ist, bin aber <br>
mit der Größe nicht so glücklich, weil ich das alles in 3D ausdrucke. Hier bin ich auf <br>
eine Idee gekommen, wie ich das ändern könnte. Weil bei Änderungen an Teilen müssen <br>
diese oft neu gedruckt werden. Jedenfalls habe ich das in der Vergangenheit so gemacht. <br>
Aber nun soll das neue Konzept flexibler werden, ohne das ich Unmengen an Material <br>
verdrucke, was - bei großen Teilen - ja auch immer dann gleich Tage dauert.
</blockquote>
Hier sieht man dann die Formatierung.
Searcher
05.12.2020, 15:55
so sieht die formatierung bei dir aus:
35341
Ich schreibe größere Beiträge im Windows Notepad mit eingeschaltetem "Word Wrap" vor um dort automatische Zeilenumbrüche zu bekommen.
Wenn ich dann alles kopieren und ins Forum einfügen würde, sähe es so wie oben aus. Deshalb schalte ich vor dem Kopieren schnell noch das "Word Wrap" aus. Danach alles Kopieren und Einfügen. Dann landen alle Absätze und Zeilenumbrüche wie im Notepad entworfen im Forum.
Gruß
Searcher
Irgendwie ist das ein wenig doof, dass man keinen Rahmen vorgeben kann, in dem man schreiben will (Ausgabe im DIV-Container mit fester Breite bspw.). Blocksatz geht auch nicht. Anersrum nervt es mich, wenn ich einen Absatz schreibe, der dann in einer Zeile erscheint, weil mein Bildschirm so breit und der Platz im Browser vorhanden ist. Dazu kommt dann womöglich ein Bild, das eingefügt wird, das steht dann ganz links, der Text geht noch 20cm nach rechts drüber raus.
Aber mal zurück:
@Searcher, womit erstellst Du Deine Videos? Einfach nur mit Handy-Kamera vermutlich oder?
Ich müsste wenigstens ein Programm finden, um die Tonspur eines Videos zu extrahieren. Oder ich müsste nebenbei parallel eine Aufnahme im Music Cleaning Lab laufen lassen. Das könnte ich demnächst versuchen, ob die Rechenpower dann für Tonaufnahme und Videoaufzeichnung in unterschiedlichen Programmen ausreichend ist. Und dann hinterher sehen, wie ich Ton und Bild zusammen bekomme.
MfG
Searcher
06.12.2020, 05:25
@Searcher, womit erstellst Du Deine Videos? Einfach nur mit Handy-Kamera vermutlich oder?
Hallo Moppi,
ich habe noch eine alte Sony MiniDV Handycam. Damit mache ich die Videoaufnahmen (und Fotos, da die auch noch einen Mamory Stick aufnehmen kann), übertrage die Videoaufnahmen über Firewire zum PC. Dazu verwende ich das auch alte :-) Videoschnittprogramm MAGIX Deluxe von 2004/2005 und schneide damit auch die Aufnahmen. Beim Übertragen zum PC trennt das MAGIX Video- und Audiospur/en schon und man kann sie dann auch getrennt editieren. (Alles auf dem noch älteren WINXP :-) )
Ich müsste wenigstens ein Programm finden, um die Tonspur eines Videos zu extrahieren.
Es gibt viele Freeware Programme um Videos zu bearbeiten.
Vielleicht könntest Du ein kurzes Stück Video posten und man könnte helfen zu suchen um eins zu finden, daß Dein Format unterstützt. Da gibt es ja unendlich viele Möglichkeiten.
Gruß
Searcher
Ich benutze OBS-Studio das funktioniert ganz gut. Habe dort jetzt auch die Funktion gefunden, den gesamten Bildschirm aufzunehmen. Das Dateiformat von OBS ist "MKV". "MP4A" ist das Tonformat bei den MKV-Dateien. Ich habe noch den Kigo Video Konverter, der kann die MKV-Dateien vom OBS lesen, aber nicht konvertieren. Was schade ist, weil ich dort auch Start und Endzeit angeben könnte. Mit einem Schnittprogramm von Roxio kann ich MKV auch bearbeiten, aber das Ergebnis irgendwie nicht speichern, bleibt das Programm hängen. Ich habe eine Online-Möglichkeit gefunden, das MKV-File hochzuladen, wenn ich es dort runter lade, bekomme ich MP4 zurück.
ein kurzes MKV-Video:35345
@Inka
ich werde in Zukunft nicht mehr so viele Zeilenumbrüche einfügen - mal schauen, ob das gelingt.
MfG
Powered by vBulletin® Version 4.2.5 Copyright ©2024 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.