html-Code für virtuelles website-Button-Pad

Zitat:

---

Zitat von Moppi

Das ist nicht ganz so einfach. Das nodeMCU ist etwas langsam. Ich hatte schon mal gelesen, dass die keine sher hohe Datenübertragungsrate per WiFi haben, aber mich stellt das so nicht ganz zufrieden. Einen Anfang habe ich gemacht, bis ich jetzt gesehen habe, wie lang das mit der Übertragung der Seite dauert.

Hier mal der vorläufige Code:

Code:

---

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
 
const char* ssid = "....";
const char* password = "....";
 
ESP8266WebServer server(80);  //instantiate server at port 80 (http port)
 
  String page = "";
  //the HTML of the web page
  String s1="<div style='display:block;overflow:visible;'><div role='presentation' style='display:table'>";
  String s2="<div style='display:table-row;'>";
  String s3="<div style='display:table-cell;position:relative;vertical-align:top;width:1.5em;padding:0.1em;'><form style='height:0.65em;'><input type='text' name='but' value='";
  String s31="' maxlength='1' style='visibility:hidden;width:0;height:0;'><input id='but#0' type='submit' value='*' style='margin:0;height:1.5em;width:1.6em;font-family:monospace;font-style:normal;font-size:133%;color:#000000;font-weight:700;text-align:center;line-height:170%;border-radius:0.375em;border-width:1px;'></form></div>";
  String s4="</div>";


    int tableWidth=7;
    int tableHeight=7;




void setup(void){
  Serial.begin(115200);
  delay(10);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password); //begin WiFi connection
  WiFi.config(IPAddress(xxx,xxx,x,xx), IPAddress(xxx,xxx,x,xx), IPAddress(255,255,255,0), IPAddress(xxx,xxx,x,xxx));


 
  Serial.println("");
 
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
 
  server.on("/", [](){
    page = s1;
    int but = 0;
    for(int x=0; x < tableHeight; x++){
      page += s2;
      for(int j=0; j < tableWidth; j++){
        page += s3 + String(but) + s31;
        but++;
      }
      page += s4;
    }
    page += s4;
    server.send(200, "text/html", page);
  });
  server.begin();
  Serial.println("Web server started!");
}
 
void loop(void){
  server.handleClient();
  yield();
}

---

Es wäre in der Größe, per CSS, noch optimierbar, aber besser wär's mit JavaScript auf der Seite zu arbeiten und einem unsichtbaren Frame, zwecks Datenübertragung.


MfG

---

die Eingabe per Buttons ist nicht zeitkritisch, das dauert eh bis man ein Muster mit etwa 10-20 Buttons gedrückt hat.
Dann muss es per Sende-Button ("Fertig") übertragen weden,
und dann beginnt der Trainings- und Lernalgorithmus, der dann eh nicht mehr auf das Netzt per html zugreift und (je nach Netzstruktur und Musterzahl) durchaus mehrere Stunden dauern kann.

Im "Erinnerungsmodus" kann man dann dem Netz verschiedene Muster präsentieren (dauert so lange wie oben)
und dann legt es die gelernten Perzeptronwerte an (Netz-Matrix),
das dauert dann erfahrungsgemäß nur wenige Sekunden bis zur Auswertung.



Update:
dein html-Buttonpad sieht schon sehr schön aus, jetzt müssten die Buttons noch Zahlen tragen (0-63, zeilenweise hochgezählt),
Farbwechsel sobald gedrückt (grau->gelb o.ä.)
und dann müsste das Gesamt-Muster mit allen Nullen und Einsen für alle 64 Buttons als Block per Extra-Button an den esp gesendet werden, zur Weiterverarbeitung als net-inputs.

Anm.: WiFi.config() hat subnet 255,255,255,0 am Schluss!

WiFi.config(IPAddress(192,168,2,99), IPAddress(192,168,2,1), IPAddress(192,168,2,1), IPAddress(255,255,255,0));

Vergiss es wieder, ist schon überholt. Nicht mit dem alten Krempel den Server belasten.

Hier mal ein Bild, ob das so dann ok ist. In den Feldern stehen nachher 0, 1 oder Leer und X (oder was anderes). Zum Aussuchen. Beim reinklicken würde sich der Inhalt ändern. Wenn alles fertig gesetzt ist, würde es ein Mal übertragen. Das ist dann aber vom Code her schon wesentlich kürzer so.


Anhang 34433



MfG

zusätzlich zu
[Senden/OK]

bräuchte man zum Umschalten der Betriebsmodi noch einen Button
[Training]

und einen Button
[Erkennen],

aber das ginge zur Not auch über 2 echte Buttons an je einem GPIO Pin

- - - Aktualisiert - - -

edit, hat sich überschnitten:

ja, sieht top aus!
da ginge sogar auch ' ' für 0 und 'X' für 1, wenn kein Farbwechsel stattfindet und keine Zahlen in den Feldern stehen
(Zahlen in den Feldern würden das Debuggen vereinfachen, muss aber nicht sein)

- - - Aktualisiert - - -

man würde dann

1. entscheiden per Buttonclick, ob trainiert oder erkannt werden soll (evtl. auch Radio-Buttons)
und
2. "Senden/OK" würde dann das Muster für den gewählten Modus übertragen ans Netz.

Man kann rein schreiben, was man möchte. Es wäre auch die Hintergrundfarbe zu ändern, was ich dann persönlich für besser fände, wenn das Feld ein Muster abbilden soll.

Das mit den "Betriebsmodi" verstehe ich noch nicht.
Das mit dem Muster trainieren kann ich mir vorstellen, aber dann fehlt die Zielvorgabe, was am Ende erkannt werden soll.

Jetzt ist es so nur ein Eingabefeld. Man könnte durch anklicken der Felder ein Muster erstellen / eingeben und abschicken.

Mal sehen ...



MfG

man trainiert mehrere Eingabemuster gemeinam mit enem jew. Ausgabemuster (Ziel), z.B
000
0
(training)

010
0
(training)

100
0
(training)

110
1
(training)


dadurch lernt das Netz, die verschiedenen Eingabemuster zuzuordnen.
Dabei werden nicht die Einzelmuster gespeichert, sondern die Neuronen verändern ihre innere Struktur für alle Muster gemeinsam:
sie bilden eine interne Variablen-Matrix aus internen Gewichten und Thresholds, die auf alles gemeinam passt.

gibt man nun ein
011
drückt man auf
(erkennen)
dann wurde dieses Muster bisher nicht trainiert, trotzdem wendet das Netz seine Matrix auf dieses Muster an und erzeugt ein Ergebnis, das irgendwie zu den bisherigen Mustern passt, möglicherweise wird es auch eine 1 sein, aber das muss man ausprobieren: es lässt sich nicht vorhersagen.

Als Inputschicht könnte man die obersten 9 Zeilen des html-Buttonpads verwenden, als Ausgabeschicht die unterste, 10.

Ich bin aber gestern abend/nacht auf eine Sache gestoßen, als ich ein einfaches meiner alten Netze auf den esp8266 portieren wollte:

alle meine bisherigen MCUs konnten Multithreading (Lego NXT und Arduino Due), und beiden machte es nichts aus, wenn eine Funktion für eine Berechnung sehr lange gebraucht hat (Minuten bis Stunden).

Der esp8266 kann aber überhaupt kein Multithreading, und er stürzt ab und rebootet, wenn eine Funktion den Prozessor länger als wenige (1-2) Sekunden komplett mit einer Berechnung belegt. Training aber kann mehrere Stunden dauern, und auch Auswertungen (Erkennen) zumindest mehrere Sekunden

Das zweite Problem lässt sich vielleicht (!) durch etliche delay(1) in der Trainingsfunktion kaschieren (weiß ich noch nicht),
aber Mutithreading ist unverzichtbar, wenn man im Betrieb das Gehirn (ich nenne es HAL) simultan Muster bearbeiten als auch Inputs, Steuerbuttons und das Display bedienen soll.
Würde man das alles Spagetticodemäßig hintereinander schreiben, wird es nicht nur unübersichtlich, sondern auch extrem langsam, weil dadurch die sehr schnellen Gehirnroutinen im Mikrosekunden-Bereich ausgebremst werden durch TFT-Anzeige- oder GPIO- und html-Abfrageroutinen, die man nur 1x pro Sekunde aktualisieren muss.
Ein dritter Grund, was gegen den esp8266 spricht: er hat zu wenie GPIOs, um auch zusätzlich neben lokalen Pin-Buttons eine SD-Karte per SPI anzusprechen.

Der esp8266 macht daher keinen Sinn als Basis für ein NN, zumindest bei meinen NN-Pogrammen, die ich bereits geschrieben habe.
Es müsste ein Arduino Due sein wie früher, der kann aber keinen Webserver aufbauen,
oder ein esp32 ,
denn nur diese beiden können derzeit Multithreading (Due Scheduler bzw. std::thread).

Da der Due wegen mangelndem html aber komplett rausfällt und wir auch kein Hardware-Buttonpad haben, bleibt nur mein ESP32 als einzige Basis (meiner hat ein Adafruit Feather HX8367 Display) , für die ich die NNs neu programmieren könnte.
Allerdings verwendet der ESP32 auch etwas andere wifi- und webserver libs als der esp8266.

Mir ist daher jetzt noch nicht klar, wie es weitergehen kann, und ob es Sinn macht, zunächst mit den esp8266-html-Buttons zweigleisig zu fahren, mit absolut ungewissem Ausgang...

Zitat:

---

alle meine bisherigen MCUs konnten Multithreading (Lego NXT und Arduino Due), und beiden machte es nichts aus, wenn eine Funktion für eine Berechnung sehr lange gebraucht hat (Minuten bis Stunden).

---

Macht es dem nodeMCU auch nicht, wenn man im Programmcode mitteilt, dass man beschäftigt aber aktiv ist. Der Befehl dafür ist: yield();


Ich habe das mal, so weit es bis jetzt mit den Infos möglich war, erstellt und etwas beschrieben. Datei hier zum Herunterladen.

Anhang 34434

MfG

Zitat:

---

und einem unsichtbaren Frame, zwecks Datenübertragung.

---

https://www.html5rocks.com/en/tutori...ockets/basics/

geht auch etwas eleganter als ständig http requests zu schicken :)

Und weil ichs persönlich liebe hole ich nochmal die Python Keule raus und sag mal

https://github.com/pallets/flask

Da fällt das parsen etwas leichter und man kann die Webseiten als richtige HTMl Files schreiben und muss dann wie bei PHP in den Patzhaltern nur den PyCode packen der dann aus Daten die Lücken des HTML Dokuments an der entsprechenden Stelle ergänzt.

Finde ich persönlich eleganter als den HTML code als String mit ein zu compilen (und man kann auch die files on-the-fly updaten wenn was nicht stimmt und muss nicht immer erst alles compilen und hochladen

Zitat:

---

Zitat von Ceos

https://www.html5rocks.com/en/tutori...ockets/basics/

geht auch etwas eleganter als ständig http requests zu schicken :)

---

Wenn Du es kannst: super! Mach bitte ein Beispiel für nodeMCU.

Zitat:

---

Wenn Du es kannst: super! Mach bitte ein Beispiel für nodeMCU.

---

Netter Beißreflex ... war als Denkanstoß zu verstehen und um etwas Last aus der Verbindung zu nehmen, aber wenn man sich zu fein ist mal damit zu beschäftigen ... bitte ... daher nur eine vereinfachte Antwort und viel Glück

https://www.tutorialspoint.com/html5..._websocket.htm

für die NodeMCU Seite braucht man allerdings ein klein wenig mehr Einrichtungsarbeit

https://github.com/micropython/micropython (Als Grundlage)
https://github.com/pfalcon/picoweb (Die Flask Version für den kleinen Speicher)
https://github.com/hiway/micropython...ockets-modules (Die Websocket Anbindung)

Allerdings habe ich damals den richtigen Flask genommen und etwas angepasst damit er auf µPy läuft. Hab sogar mal Owncloud drauf laufen lassen, aber die Datenrate war eher bescheiden :P

Zitat:

---

Zitat von Moppi

Wenn Du es kannst: super! Mach bitte ein Beispiel für nodeMCU.

---

schließe ich mich an, in Arduinisch!
Python ist hier völlig OT, denn dann müsste ja auch das NN in Python geschrieben werden, und das ist völlig illusorisch für meine Zwecke.

yield() ist aber nichts anderes als delay(1) in Arduinsch, das hatte ich ja schon angesprochen und damit müsste ich es ausprobieren.

Dennoch nützt es nichts, wenn die cpu kein MT kann.

Wir haben in diesem Forum keine Beispiele für die Programmierung von NN in C
für Arduino z.B.
Aus diesem Grund hatte ich dieses in einem andern Thread nochmals geäußert.


Wenn man sich zu weit von der Basis entfernt, die ich hier bei Arduino und nodeMCU
sehe, entfernt man sich zu weit von der Mehrzahl der User in diesem Forum.


Ich hatte diesbezüglich schon woanders zum Nachdenken anregen wollen, als ich
sinngemäß schrieb, dass man sich überlegen soll eine Art Supercomputer zu verwenden.
Also irgendwas leistungsstarkes mit mehreren GHz Taktrate, mehreren Gigabyte RAM
und Festplattenspeicher, wenn man auf diesen Komfort dieser Geräte zurückgreifen
möchte: Schnelligkeit, Multitasking, Webfähigkeit. Dort hätte man dann alle Möglichkeiten,
wie Webserver mit PHP, man kann Javaprogramme drauf laufen lassen, man kann
Webanwendungen drauf laufen lassen, die ihre Datentransfer auch anders abwickeln,
Stichwort: AJAX.


Wenn ich hier jetzt anfange, mich in Neuronale Netze einzuarbeiten und dies in einem Thread
darzustellen, weiß ich genau was passiert. Nämlich dasselbe, was soeben auch hier passiert ist:
dann - und genau dann, nicht vorher - kommen die Leute die "Ahnung" davon haben und
den Thread so richtig aufmischen, mit diversen, nicht zielführenden Bemerkungen oder
"gut gemeinten Ratschlägen".
Deshalb wünschte ich mir etwas zum Thema Neuronale Netze, um die User hier zu wecken, die
etwas davon verstehen und sich der Sache annehmen, damit wir alle hier etwas davon haben und
es nicht in einem Zerreden des Themas endet.


Ich habe schon vieles gemacht und auch eine Webanwendung die mittels Sockets / AJAX-like,
Daten mit einem Webserver austauscht. Die Anwendung ist toll geworden, hier aber nicht brauchbar!

Ich sehe mein Projekt zuhause momentan als bestes Beispiel, wie weit man sich von einer allgemein handhabbaren Basis,
für viele Menschen / User - entfernen kann. Deshalb bin ich dafür, ganz klein anzufangen und es für jeden
verständlich zu machen. Hier jetzt besonders das Thema neuronales Netz.








MfG

Hinzu kommt, dass die html-Steuertasten (Senden, Lernmode, Erkennmode, ggf. auch weitere für ResetInputs, SD_Speichern und Pause) ständig während aller HAL-Modi parallel zu Steuerzwecken abgefragt werden müssen, d.h. wenigstens 1-2x pro Sekunde gepollt werden müssten.

Der Due wäre eine gute Basis, wegen MT, und billig ist er auch, man braucht aber Dutzende GPIO-Switches, die einrasten.
Der ESP32 wäre eben die andere Alternative, mit der ich es u.U. umsetzen könnte, aber die komplette html-Sache müsste ich aus der Hand geben.

Auch der Raspi kann ja MT (und ist ja vergleichsweise schon ein kleiner "Supercomputer"), aber auch für ihn gibt es kein Hardware-Buttonpad und dafür kann ich auch keinen html-webserver schreiben, und daher bräuchte ich auch für ihn jemanden, der die html-Seite schreibt und im Programm händelt - eigentlich zu schwierig, wenn man es richtig überlegt.

PS,
Ich will aber gerne anfangen, den html-Code für die Key- und Steuer-Buttons zu testen, wie weit ich damit komme, ohne Garantie aber, dass es nicht bereits ein paar Stunden später doch nicht weiter komme.

Zitat:

---

Hinzu kommt, dass die html-Steuertasten (Senden, Lernmode, Erkennmode, ggf. auch weitere für ResetInputs und Pause) ständig während aller HAL-Modi parallel zu Steuerzwecken abgefragt werden müssen, d.h. wenigstens 1-2x pro Sekunde gepollt werden müssten.

---

So was in der Richtung hatte ich auch vermutet.
Das macht es dann eigentlich unmöglich. Da der Browser immer erst eine Anfrage senden muss. Wie man das, mit einem ndeMCU, anders hinbekommen könnte, ist mir bislang nicht bekannt. Möglichkeiten gibt es theoretisch. Früher hat man die verwendet um, per PHP, ein Webchat zu bauen. Dazu kann man die Verbindung bestehen lassen, Daten an den Browser schicken (der ständig lauscht) und der verarbeitet sie, sobald sie angekommen sind. Das geht dann ohne ständige Serveranfragen.

Wenn Du aus einem Programm heraus z.B. das Feld dauernd aktualisieren wolltest, ohne dass der User dauernd klicken muss, ist das in einer erträglichen Geschwindigkeit nicht möglich, weil ständig der Netzwerkverkehr dazwischen ist, der ausbremst. Eine LED am µC kannst Du in Bruchteilen einer Sekunde hunderte Male ein- und ausschalten.

Allerdings wäre das, dies per HTML-Seite zu realisieren, die eleganteste Lösung, wenn jemand das dann ausprobieren möchte (dagegen stehen ca. 25,- für so ein beleuchtetes Originalpad in Größe 4x4 und das muss noch zusammengebaut werden, LEDs eingelötet werden).

MfG

ja, stimmt, und daher sind zumindest unabhängige Threads für Gehirn (HAL-Schicht) und Steuerungs-Interface (Website, Display, Buttons) unerlässlich.

Wenns nur Arduino sein soll, kann ich leider nicht direkt helfen

aber hier ein paar Links die vielversprechend aussehen für die "Server" Seite der Websockets auf Arduino Basis (sind aber ESP spezifisch):

https://tttapa.github.io/ESP8266/Cha...WebSocket.html (Doku)
https://github.com/gilmaimon/ArduinoWebsockets (Quelle)

Ich habe es nur in Python und Flask gelöst, weil mir das persönlich einfacher fiel aber es war defintiv effektiver als ständiges Refresh eines versteckten div/frame

Der ESP8266 scheidet doch aus, wie schon oben erklärt, da er kein MT kann. Man könnte dafür höchsten html-Seiten testen (d.h. zu reinen html-Testzwecken), aber kein NN aufbauen und steuern.
Ich programmiere aber nur in der Arduino-IDE, daher der ESP32 als Vorschlag, aber selbst das ist schon sehr aufwändig ohne Hardware-Keypad, und den kompletten html Teil müsste wer anders entwickeln und einbinden nach meinen Vorgaben, das macht es doppelt schwierig.

Und das heißt @Ceos:
echten Arduino-Code schreiben, den ich direkt kopieren+pasten kann, samt aller weiteren Änderungswünche.

PS,
Zeitkritisch sind hier allerdings v.a. die genannten Steuertasten (Senden, Lernmode, Erkennmode, ggf. auch weitere für ResetInputs, SD_Speichern und Pause) , nicht die 10x10 keypad-Matrix.

Weitere html-Funktionen kommen aber noch hinzu, wenn man kein gemeinsames TFT Display für Menüs hat und auch das über html laufen muss:

überschreiben? ja/nein
nicht gefunden: wiederholen/Abbruch
Netz-Ausgabewert: 123.4567
Wert korrekt? ja/nein/Abbruch

etc.

das kann ich zwar einfach über mein HX8357 TFT ausgeben, aber nur für dieses, denn es ist fest an meinem ESP32 angeschlossen.
A-Bär: man kann sich ja langsam Schritt für Schritt an diese Probleme herantasten.

Ich habe die letzten Antworten noch nicht alle aufgeholt, ihr tippt schneller als man Beispiele suchen kann!

Zitat:

---

Und das heißt @Ceos:
echten Arduino-Code schreiben, den ich direkt kopieren+pasten kann, samt aller weiteren Änderungswünche.

---

deinen Anforderungen kann man ja nicht gerecht werden, dafür brauchte ich schon Bezahlung ....

so um jetzt hier einen Punkt damit zu machen nurnoch eine Sache:

Wenn ihr beide nicht immer so schnippisch Antworten würdet und euren Beißreflex mal im Zaum halten könntet, würdet ihr nicht ständig Gegenkommentare bekommen die das Topic "zerreden" oder Beispiele die das Thema "verwässern"

Packt euch mal an der eigenen Nase und bleibt bei euren Antworten einfach mal sachlich und nehmt einen Denkanstoss hin ohne dieses ständige "mach mal vor" hinten dran zu packen, das löst nämlich meinen Beißreflex aus, weil ich sowas einfach unverschämt finde (warum habe ich auch schon mehrfach erklärt)


NACHTRAG:

Zitat:

---

@Ceos,
das ist nicht schnippisch, hier hilft nur echter Code, und den zu schreiben macht zweifelsfrei eine Menge Arbeit, und anders geht es nicht.

---

Bis hierher geh ich konform und sehe dass du verstehst was ich meine.

Zitat:

---

Aso wenn du etwas postest:
bitte gerne echte Code, ansonsten bitte eher nichts.

---

Aber den hättest du einfach weglassen sollen, das ist GENAU das was ich unverschämt finde, LASS ES einfach

erneuter NACHTRAG:


das nichts auch noch nachträglich FETT zu machen setzt dem ganzen noch das Sahnehäubchen auf, du bist und bleibst unverbesserlich

@Ceos,
das ist nicht schnippisch, hier hilft nur echter Code, und den zu schreiben macht zweifelsfrei eine Menge Arbeit, und anders geht es nicht.
Also wenn du etwas postest:
bitte gerne echten Arduino-C++-Code, ansonsten bitte eher nichts.

- - - Aktualisiert - - -

@Moppi:
könntest du denn auch auf einem ESP32 arbeiten?

Wenn für Deine Software ein Multitasking notwendig ist, weil das aus Gründen der schnellen und einfachen Handhabung verschiedener Codeschnipsel für Dich unabdingbar ist, dann bist Du - für meine Begriffe - zu weit weg.
Es gibt auch tolle Neuronale Netze, die mit PC erstellt werden können, schnell anzulernen sind und praktisch toll sind (Stichwort NVIDIA). Das kann man hier auch vorstellen, aber nicht erwarten, dass dies jemand "Nachbauen" will oder auch nur ausprobieren.

Daher, weil Du auch sagst, dass wir so nicht weiter kommen, ohne hardwaretechnisch immens aufzurüsten, wende ich mich dem Thema Arduino zu und beschäftige mich etwas damit. Einen guten Link dazu gab es ja. Mal schauen, wie weit man damit kommt. Leider gibts hier offenbar keinen, der in der Lage wäre, das Thema Neuronales Netz für Bastler verständlich darzustellen und Projekte, angefangen vom Arduino UNO, über schnellere nodeMCUs mit mehr Speicherplatz und schließlich darüber hinaus verständlich darzustellen und zu beschreiben. Wenn man im Laufe der Entwicklung ableitet, dass man noch schnellere und noch mehr Speicherplatz und noch andere Technik (wie Multitasking) benötigt, ist das durchaus sinvoll und hat seine Berechtigung und macht dann auch Sinn.


Also gut. Das war ein Exkurs in die Richtung, scheitert bei mir aber am Multitasking.



MfG

- - - Aktualisiert - - -

Einen ESP32 habe ich _noch_ nicht. Der ist mir noch zu neu. Die meisten Leute haben wohl noch nodeMCUs der alten Generation im Schubfach. Ich meine mit 80MHz (?) und 1 MB Programmspeicher, sowie 3 MB für SPIFF müsste schon was machbar sein.

ja, das stimmt leider, das NN (HAL-Module für isoliertes Muster-Training und -Auswerten) läuft zwar ohne MT, aber für die Steuerung (User-Interface, Dashboard) ist bei mir zusätzlich MT notwendig.

Zitat:

---

Zitat von Ceos

... deinen Anforderungen kann man ja nicht gerecht werden, dafür brauchte ich schon Bezahlung ....

---

Meinst Du nicht, ceos, Du bist hier damit an der falschen Adresse?

Das hier sind Hobbybastler und mehr, in diesem Forum. Gerade versucht HaWe - aus seiner eignen Quellcodesammlung - was zur Verfügung zu stellen, was man nachvollziehen kann. Ich versuche ihn zu unterstützen und tue das praktisch, indem ich mich auch Stunden hinsetze und etwas zusammenbaue, was - eventuell - nützlich ist. Ich habe das kostenlos erledigt, damit wir hier voran kommen, in diesem Forum. Solche Threads sind wohl nicht geeignet, seine Fähigkeiten zu presentieren, indem man Links in die Runde wirft, die keine direkte Problemlösung bringen, um dann zu werben, dass man Geld haben möchte, wenn man sich hier beteiligt.




MfG

danke, moppi!
aber bitte jetzt keine OT-Diskussionen darüber,
Code zum testen und Experimentieren aber immer gerne!

Zitat:

---

Meinst Du nicht, ceos, Du bist hier damit an der falschen Adresse?

Das hier sind Hobbybastler und mehr, in diesem Forum. Gerade versucht HaWe - aus seiner eignen Quellcodesammlung - was zur Verfügung zu stellen, was man nachvollziehen kann. Ich versuche ihn zu unterstützen und tue das praktisch, indem ich mich auch Stunden hinsetze und etwas zusammenbaue, was - eventuell - nützlich ist. Ich habe das kostenlos erledigt, damit wir hier voran kommen, in diesem Forum. Solche Threads sind wohl nicht geeignet, seine Fähigkeiten zu presentieren, indem man Links in die Runde wirft, die keine direkte Problemlösung bringen, um dann zu werben, dass man Geld haben möchte, wenn man sich hier beteiligt.

---

Sich darüber aufregen dass Themen verwässert/zerredet werden und selber immer wieder Antworten provozieren ist aber auch nicht hilfreich. Für mich war das Thema eigentlich geklärt.

Ich habe bereits ewähnt es war ein Denkanstoß (aufgrund der von dir selbst erwähnten Leistungsproblematik und dem in meinen Augen sehr schlechten Vorschlag einen hidden Frame für Datentransfer zu nutzen) eine alternative Methode zu betrachten.

Einen eigenen Code aufbauen nur der Demo wegen wenn man es für den eigenen Ansatz selber erforschen und gleich anwenden könnte halte ich nicht unbedingt für Zielführend(vor allem wenn du mehr zeit damit verbringst den code aufgrund mangelnder Praxis in Arduino lauffähig zu bekommen als die eigentliche Funktion zu demonstrieren .... Wenn ich HaWe einen Teilcode schicke reicht es ihm nie aus, es muss auf seiner Hardware laufen, wobei ich nicht die identische habe und es immer deutlich mehr Zeit kostet etwas universal lauffähig zu machen als den funktionalen Code zu schreiben der die Anwendung demonstriert).

Ich war zwar schon dabei den Python Part aus meinem Fundus zu suchen aber es war scheinbar einfacher etwas (in herablassenden Ton) zu verlangen

Zitat:

---

Wenn Du es kannst: super! Mach bitte ein Beispiel für nodeMCU.

---

statt mal nachzusehen was das ist und ob man das anwenden kann. Und dann hatte ich auch keine Lust mehr und hab die Projekte zum nachlesen verlinkt. Auf die Aussage dass man für die NN Arduino braucht habe ich dann noch die passenden Arduino Referenzen für WebsocketsServer rausgesucht.

Du darfst gerne eine Seite zurück gehen und die Historie meines letzten Beitrages nachverfolgen. Es geht um die Art der Kommentierung und vor allem auch die wie nacheditiert wird um der dem eignen Gegenkommentar noch Nachdruck zu verleihen.

Mein Finaler Kommentar dazu ist nur, wenn du eine Idee gezeigt bekommst, erstmal reinsehen, bewerten und ignorieren oder sich damit befassen und ggf. Anwendungsbeispiele in höflichem Ton erfragen.

Aber schön dass wieder am Text vorbei gelobt wird.

und jetzt bitte Schluss mit OT und zurück zum Topic!

Um nochmal zurückzukommen:

Der Code ist momentan so gestaltet, dass man ein Bitfeld / Array / Matrix mit Nullen und Einsen beschickt oder daraus liest. Das entspricht dem Muster, das über den Browser eingegeben wurde. Klickt der User auf "ok" wird das Muster übertragen und kann dann also jederzeit verarbeitet werden. Wenn der Browser (per Refresh z.B. oder wenn der User einen Button klickt) die Seite neu lädt, wird das Muster im Browser ausgegeben.
Das Bitfeld kann also stets aktualisiert werden, unabhängig von der Darstellung. Die Darstellung im Browser ist dann nur nicht in Echtzeit möglich.

Ob das brauchbar ist, kannst nur Du entscheiden.



MfG

dankeschön, ich teste es gerne noch mal !

was mir noch nicht klar ist:
wir haben ja insg. 10x10=100 keypad-Felder auf der html-Website.
Im Programm hätte ich einen array-buffer
float/buffArray[100];
zum temporären Speichen.

wo und wie kann ich die html-keypad-Werte auf diesen buffer-array übertragen zur Weiterverarbeitung,
und wie merkt meine loop(), ob per [ok/Senden] tatsächlich soeben neue keypad-Werte übertargen wurden?

Guck mal in die ZIP-Datei aus Beitrag #6. Ich habe dort so gut erklärt, wie ich dachte, dass es notwendig ist.
Es fehlen, nach Deinen Angaben, sicherlich noch Buttons. Aber das wusste ich noch nicht, welche genau. Wenn das so nun doch nicht wirklich zu gebrauchen ist, müssen wir die auch nicht einbauen - logisch.
Wann was passiert, liegt an Deinem Programm. server.handleClient() sorgt für die Abwicklung auf Seite des Webservers, von allein passiert dort nichts. Wird das nicht immer wieder aufgerufen, gibt es
irgendwann einen Time-Out-Fehler im Webbrowser. Da der Bitpuffer / Array ... global zugänglich ist, solltest Du von überall her dort rein schreiben oder dort heraus lesen können. Besonderheit nur: Datentyp ist boolean



MfG

hmm - danke, aber wie ich weiß, wann [ok/Senden] gedrückt wurde und wie ich dann die Daten auf meinen buffer übertrage, weiß ich dadurch immer noch nicht.

Wie schon gesagt, html- und webserver Code und was man wie damit anstellt ist nicht meine Welt...

der Buffer muss bei mir strenggenommen eigentlich float sein, aber das kann man ja umwandeln): (editiert)

float buffArray[100];

Zitat:

---

wenn keine neuen Daten verfügbar sind, muss ich ja keine Daten von der website pollen, und die loop kann diesen Schritt überspringen.

---

Wenn es notwendig ist, kann das eingebaut werden.

Zitat:

---

der Buffer muss bei mir allerdings signed char sein

---

Das weiß ich nicht, ob Du die Daten von einem in das andere Array überträgst. Dachte ich mir so. Sonst kann man den auch auf char ändern, belegt dann aber ein Vielfaches mehr Speicherplatz.




MfG

das mit bool oder char ist egal, wenn es sich um die Daten auf dem Server handelt.
Übertragen auf andere float-Arrays oder Matrizen muss ich es eh, weil nur die ersten 9 Zeilen (90 Werte) vom html-keypad für die Inputs sind und die 10. Zeile (10 Werte) für Ziel-Outputs, das muss man evtl auch flexibel anpassen (ggf. 8 Zeilen + 2 Zeilen etc.).
Ein NN rechnet aber grundsätzlich mit floats, nicht mit int, char oder bit.

Ich muss es nur zunächst übertragen auf lineare Arrays, aber nur dann, wenn Daten auch neu verfügbar sind (OK/senden-Button auf der website frisch gedrückt).

Ein bool Datentyp benötigt ja übrigens auch denselben Speicherplatz bei C/C++ ( stdbool.h ) wie ein char oder byte.
http://www.mrknowing.com/2013/10/08/...eichergroesse/

Zitat:

---

Ein bool Datentyp benötigt ja übrigens auch denselben Speicherplatz bei C/C++ ( stdbool.h ) wie ein char oder byte.

---

Habe ich nicht mit gerechnet. Dann sag noch mal, was Du für einen Datentyp brauchst, dann sparen wir die Umwandlung.

Zitat:

---

Ich muss es nur zunächst übertragen auf lineare Arrays, aber nur dann, wenn Daten auch neu verfügbar sind (OK/senden-Button auf der website frisch gedrückt).

---

Ich habe eine Variable (bool isChange) eingebaut, zum Abfragen nach server.handleClient();

Anhang 34435

MfG

Auf der website fürs 10x10 keypad ist signed char oder bool ok.

(float oder double wäre hier übertrieben und wirklich ein Speicherfresser)

Die 100 website-keys müssen zeilenweise als Array durchgezählt sein von 0...99, nicht Reihe/Spalte.

Code:

---

0  1  2  3  4  5  6  7  8  9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
...

---

Die Übertragung muss dann zunächst so erfolgen (verkürzt, die echte Umwandlung ist etwas komplizierter und die mache ich später selber):

Code:

---

float bufferArray[100];  // global
//...
// Kopieren sobald neue Daten verfügbar:
  for (int i=0; i<100; i++} { bufferArray[i]=(float)websiteKey[i]; }

---

ich komme aber mit dem Reinkopieren des neuen Schnipsels nicht klar.
Kannst du bitte den vollständigen, kompletten Code posten?
Am besten als Code in Code-Tags, kein zip-Anhang

Zitat:

---

Zitat von HaWe

Die 100 website-keys müssen zeilenweise als Array durchgezählt sein von 0...99, nicht Reihe/Spalte.

---

Sind sie.

Zitat:

---

Zitat von HaWe

ich komme aber mit dem Reinkopieren des neuen Schnipsels nicht klar.
Kannst du bitte den vollständigen, kompletten Code posten?

---

:!: Anhang 34436



Auf neue Daten prüfen
if (isChange) ...


Kopieren sobald neue Daten verfügbar
for (int i=0; i<100; i++} { bufferArray[i]=(float)matrix[i]; }






MfG


PS:
Benutze lieber ZIPs, weil der Thread so leserlicher bleibt.
Ich habe im Thread nochmal etwas gelesen, ob noch irgendwas in den Code eingebaut werden soll, was ich übersehen habe.
Für das nodeMCU hatte ich ein kleines Projekt geplant. Aus diesem Grund kam ich überhaupt auf das Tastenfeld per HTML.
Du musst schauen, ob es so praktikabel ist, wenn nicht, dann nicht. Alle meine Projekte beginnen so, dass ich mit unbekannten
Dingen beginne oder mit denen, die am schwierigsten sein könnten; um frühzeitig ein Scheitern zu erkennen und dann abzubrechen.
Wenn Du das lieber anders lösen möchtest, als mit einer HTML-Seite, habe ich damit also keinerlei Problem. Alles i.O.

zip Anhänge bringebn nichts, besser man kann es dirket lesen, um sich darüber zu verständigen.

Code:

---

float bufferArray[100];

uint32_t timestamp=0, sec=0;


void loop(void) { 
  server.handleClient();
  // Kopieren sobald neue Daten verfügbar:
  if (isChange) {
    Serial.println("new data:");
    for (int i = 0; i < 100; i++) {
      bufferArray[i] = (float)matrix[i];
      Serial.println((String)i + ": " + bufferArray[i]);
    }
    isChange=0;
  }
  if(millis()-timestamp >= 1000) {
    sec++;
    timestamp=millis();
    Serial.println(sec);
  }
}

---

OK in Change:OK umbenannt.

wie kann man jetzt (edit: ) 5 weitere Buttons hinzufügen, in dieser Reihenfolge
Clear

Learn
Detect

(Change:OK)

Reset
Save

wenn einer gedrückt wurde, soll er ebenfalls seinen Status senden, wie Change:OK:

isClear
isLearn
isDetect
(isChange)
isReset
isSave

das will ich dann versuchen für eine Statemachine zu nutzen.

- - - Aktualisiert - - -

edit, 5 weitere Buttons

Du hattest das mit den Radio-Buttons schon mal angeführt. Das wäre eine Möglichkeit.

Das Feld könnte man so gestalten, nur am Ende einen Senden-Button, um die Daten der Form zu übertragen:

[ ] Learn
[ ] Detect
[ ] Reset
[*] Change
[ ] Save

( Senden )


Leider ist mir die Bedeutung von der Bezeichnung "Change:Ok" nicht klar, also was das genau ausdrücken soll.




MfG

Change:OK ist nur der neue Name des Buttons für (bisher) OK
s5 = "<input type="submit" value="Change: OK" style="width:14.9em;height:2em"></form>";

Clear

Detect <-> Learn

(Change:OK)

Reset
Save

"Change: OK" ist nur ein Arbeits-Name, könnte man auch "submit" oder "Change: submit" nennen.

Radio Buttons gehen nur für Learn/Detect
die anderen müssten eigene Buttons sein, die man wahlweise drücken kann.

späterer Zweck:
Clear soll einfach nur alle Keypad Felder der Website auf 0 zurücksetzen (so als hätte man die einzelnen X nochmal angeklickt) , ohne dass es neu gelernt oder erkannt wird (löschen aller bisherigen X)
Reset soll später alle bisherigen Lernschritte komplett löschen (mit Sicherheitsabfrage)
Save soll das bisher gelernte auf SD speichern (mit Sicherheitsabfrage)
(Load automatisch bei Programm-Neustart von SD)

- - - Aktualisiert - - -

PS, edit:
Radiobuttons für Detect/Learn könnten bei Umschalten z.B. entweder isLearn=1 oder isDetect=1 zurückliefern
(default wird sein: isLearn=0 und isDetect=1)
Learn schaltet in Lern-Mode
Detect in den Erkennungs-Mode
(evt. kann man das auch anders lösen, wie Radiobuttons funktionieren und was sie zurückgeben weiß ich ja auch noch gar nicht)

Das nodeMCU mit seinen Bibliotheken hat mir einige Schwierigkeiten bereitet.
Die Radio-Buttons wollten nicht funktionieren; obwohl das HTML im Browser schon funktionierte,
nur nicht, nachdem das mit dem nodeMCU verschickt wurde. Hat mich den ganzen Vormittag gekostet :(

Also bin ich doch auf Buttons umgestiegen, Quelltext hier:
:!: Anhang 34437


Neu hinzugekommen sind:

bool isLearn
bool isDetect
bool isReset
bool isSave


In der Browserzeile kann man noch sehen, welche Parameter an das nodeMCU verschickt wurden.
Habe das so gelassen, weil man dann bei der Entwicklung etwas zum Kontrollieren hat.
Kann später geändert werden.


MfG

danke, aber wie geagt:
zip Anhänge bringebn nichts, besser man kann es dirket lesen, um sich darüber zu verständigen.

Habe es getestet und noch etwas geändert + ergänzt, die Buttons werden jetzt richtig erkannt:

Code:

---

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>


// Version 0.0.2

const char* ssid = "WLAN";
const char* password = "0.0.2";

ESP8266WebServer server(80);

//-----------------------------------------------------
  //HTML und Daten für das Eingabe-/Ausgabefeld
  //einfügen im globalen Scope
  //-----------------------------------------------------
  //erstellt von (c): Moppi    @roboternetz.de
  //-----------------------------------------------------
  //Hintergrundfarbe Buttons, wenn aktiv
    const String bColorActiv = "red";
  //Breite und Höhe des ges. Feldes
    const int tableWidth = 10;
    const int tableHeight = 10;
  //Füllzeichen für Felder
    const String fillChar = "X";
  //Parameter-Array enthält den Status aller Felder
  //der Ein-/Ausgabematrix (0= AUS, 1= AN)
    bool matrix[tableHeight*tableWidth]={0};
  //Status, ob Änderungen vorliegen
    bool toChange = 0;
    bool toLearn = 0;
    bool toDetect = 1;
    bool toReset = 0;
    bool toSave = 0;
    bool toClear = 0;
  //HTML
    String body = "";
    String s1="<style>\nform{margin:0}\n#un{width:0;height:0;visibility:hidden}\n#bu{width:10em;height:2em;}\n#rw{display:table-row;}\n#ce{display:table-cell;}\n#ip{width:1.5em;text-align:center;font-weight:bold}\n</style>\n<script>dge=document.getElementById; function oc(ob){if(ob.value=='')ob.value='"+fillChar+"';else ob.value='';}</script>\n<div role=\"presentation\" style=\"display:table\"><div id='rw'><div id='ce' style=\"padding-right:1em\"><form method=\"get\"><div role=\"presentation\" style=\"margin-bottom:1em;display:table\">";
    String s2="<div id=\"rw\">";
    String s3="<div id=\"ce\"><input onclick=\"oc(this);\" type=\"text\" name=\"b";
    String s3_1="\" value=\"";
    String s3_2="\" maxlength=\"1\" id=\"ip\"></div>";
    String s4="</div>";
    String s5="</div><div id='ce'><input id=\"bu\" type=\"submit\" value=\"Change:Ok\"><p></form>";
    String s5_0="<form method=\"get\"><input id=\"bu\" type=\"submit\" value=\"Clear\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"clear\"></form>";
    String s5_1="<form method=\"get\"><input id=\"bu\" style=\"background-color:";
    String s5_1n="\" type=\"submit\" value=\"Learn\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"learn\"></form>";
    String s5_2="<form method=\"get\"><input id=\"bu\" style=\"background-color:";
    String s5_2n="\" type=\"submit\" value=\"Detect\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"detect\"></form>";
    String s5_3="<form method=\"get\"><input id=\"bu\" type=\"submit\" value=\"Reset\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"reset\"></form>";
    String s5_4="<form method=\"get\"><input id=\"bu\" type=\"submit\" value=\"Save\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"save\"></form></div></div></div>";
   
    String par="b";
  //-----------------------------------------------------


float bufferArray[100];



//-----------------------------------------------------
//-----------------------------------------------------
void setup() {

  Serial.begin(115200);
  delay(1000);
  Serial.println();

  //-----------------------------------------------------
  //Anmeldung am Netzwerk
  //-----------------------------------------------------
  Serial.println("connecting by IPAddress(192,168,2,99)");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password); //begin WiFi connection
  WiFi.config(IPAddress(192, 168, 2, 99), IPAddress(192, 168, 2, 1), IPAddress(192, 168, 2, 1), IPAddress(255, 255, 255, 0));

  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());


  //-----------------------------------------------------
  //Auswertung und Erstellung des Ein-/Ausgabefeldes
  //-----------------------------------------------------
  //Einbinden in setup() und in loop() nutzen durch
  //Aufruf von "server.handleClient();"
  //benötigt Objekt "server", erstellt im globalen Scope
  //mittels:      ESP8266WebServer server(80);
  //benötigt auch: #include <ESP8266WebServer.h>
  //-----------------------------------------------------
  //erstellt von (c): Moppi    @roboternetz.de
  //-----------------------------------------------------
  server.on("/",[]()
  {
    //Auswerten des Query-String vom Browser
    int n = 0;
    if(server.hasArg("bn")){
      if(server.arg("bn") == "clear") toClear=1; else {toClear=0; toChange=0; for(int i=0; i<(tableWidth*tableHeight); i++) matrix[n] = 0;}
      if(server.arg("bn") == "save") toSave=1; else toSave=0;
      if(server.arg("bn") == "reset") toReset=1; else toReset=0;
      if(server.arg("bn") == "detect") toDetect=1; else toDetect=0;
      if(server.arg("bn") == "learn") toLearn=1; else toLearn=0;
    }
    for(int x=0; x < tableHeight; x++){
      for(int j=0; j < tableWidth; j++){
        if(server.hasArg(par+String(n))){
          String a = server.arg(par+String(n));
          bool ic = matrix[n];
          if (a == "") matrix[n] = 0; else matrix[n] = 1;
          if (ic != matrix[n]) toChange = 1;
          n++;
        }
        if(toChange){
          toClear = 0;
          toSave = 0;
          toReset = 0;
          toDetect = 0;
          toLearn = 0;
        }
      }
    }
    //Aufbau des Feldes
    String v; body = s1; n = 0;
    for(int x=0; x < tableHeight; x++){
      body += s2;
      for(int j=0; j < tableWidth; j++){
        if (matrix[n]) v = fillChar; else v = "";
        body += s3 + String(n) + s3_1 + v + s3_2;
        n++;
      }
      body += s4;
    }
    body += s4+s5+s5_0+s5_1;
    if (toLearn) body += bColorActiv;
    body += s5_1n+s5_2;
    if (toDetect) body += bColorActiv;
    body += s5_2n+s5_3+s5_4;
    //Senden der Seite an den Browser
    server.send(200, "text/html", body);
  }
  );
  //-----------------------------------------------------



  //-----------------------------------------------------
  //Webserver starten
  //-----------------------------------------------------
  server.begin();
  Serial.println("Web server started!");

}


uint32_t timestamp=0, sec=0;
uint8_t modeLearn=0, modeDetect=0;

//-----------------------------------------------------
//-----------------------------------------------------
void loop() { 
  server.handleClient();
  // Aktionen nach ButtonClick:
  /*
  if(toClear) {
    Serial.println((String)"toClear="+toClear);
    memset(matrix , 0, sizeof(matrix));
    toClear=0;
  }
  */
  if (toChange) {
    Serial.println("new data:");
    for (int i = 0; i < 100; i++) {
      bufferArray[i] = (float)matrix[i];
      Serial.println((String)i + ": " + bufferArray[i]);
    }
    toChange=0;
  }
  if(toLearn){     
    modeLearn=1;
    modeDetect=0;
    Serial.println((String)"modeLearn="+modeLearn);
    toLearn=0;
  }
  else
  if(toDetect) {     
    modeLearn=0;
    modeDetect=1;
    Serial.println((String)"modeDetect="+modeDetect);
    toDetect=0; 
  }
  if(toReset) {
    toLearn=0;
    toDetect=1;
    Serial.println((String)"toReset="+toReset);
    toReset=0;
  }
  if(toSave) {
    toLearn=0;
    toDetect=1;
    Serial.println((String)"toSave="+toSave);
    toSave=0;
  }
  if(millis()-timestamp >= 1000) {
    sec++;
    timestamp +=1000;
    Serial.println(sec);
  }
}

---

jetzt will ich mal nach dem WE versuchen, das als Eingabe-Panel für ein NN zu nutzen!

- - - Aktualisiert - - -

PS,
auch
clear
funktioniert, es löscht alle X bei BtnClick,
nur wenn man kurz vorher OK gedrückt hat, muss man 2x clear drücken, damit man den Löschvorgang im Panel sieht.

- - - Aktualisiert - - -

noch eine Frage:
kann man in der Website erkennbar machen, ob gerade Lern-Mode oder Detect-Mode gewählt ist (vlt über die Änderung der entspr. Button-Farbe auf rot?)

Zitat:

---

nur wenn man kurz vorher OK gedrückt hat, muss man 2x clear drücken, damit man den Löschvorgang im Panel sieht.

---

was soll bei clear passieren, der Puffer geleert? Dann machen wir das so, wusste ich ja nicht.

Zitat:

---

kann man in der Website erkennbar machen, ob gerade Lern-Mode oder Detect-Mode gewählt ist (vlt über die Änderung der entspr. Button-Farbe auf rot?)

---

Die Buttonfarbe kann geändert werden. Allerdings würde sie beim zweiten Klick zurückwechseln.



MfG

ja, ich hatte es selber mit memset probiert, aber wie gesagt, manchmal braucht es einen 2.Klick

Code:

---

  if(toClear) {
    Serial.println((String)"toClear="+toClear);
    memset(matrix , 0, sizeof(matrix));
    toClear=0;
  }

---

die Buttonfarbe müsste bei Learn und Detect konstant bleiben, ggf. abhängig von den beiden anderen Variablen
modeLearn
modeDetect
die nach den Buttonclicks entspr. gesetzt werden

Code:

---

// SNIP
  if(toDetect) {     
    modeLearn=0;
    modeDetect=1;
    Serial.println((String)"modeDetect="+modeDetect);
    toDetect=0; 
  }
  if(toReset) {
    toLearn=0;
    toDetect=1;
    Serial.println((String)"toReset="+toReset);
    toReset=0;
  }
// SNIP

---