Probier mal diesen Code:
:!: Anhang 34441
Buttons färben sich, Puffer wird bei Clear gelöscht und der Status für die Buttons wird zurückgesetzt, wenn das Muster geändert wird.
MfG
Druckbare Version
Probier mal diesen Code:
:!: Anhang 34441
Buttons färben sich, Puffer wird bei Clear gelöscht und der Status für die Buttons wird zurückgesetzt, wenn das Muster geändert wird.
MfG
nochmal:
zip Anhänge bringebn nichts, besser man kann es dirket lesen, um sich darüber zu verständigen.
und: nein, es soll sich der Status von
Learn
Detect
nur dann ändern, wenn eine von beiden Tasten geclickt wurde, und dann dauerhaft so bleiben.
Wenn es vom Programm intern geändert wird, soll es sich entsprechend anpassen, damit man immer sieht, welcher Mode aktiv ist.
Der jeweilge Status wird gespeichert in den Variablen
modeLearn
modeDetect
wenn man frisch OK geklickt hat, muss man aber auch immer noch 2x Clear clicken, bis das Keypad gelöscht wird.
verwende jetzt mal bitte original meinen Code als Basis, weil ich mittlerweile schon ein aar Dinge abgewandelt habe, u.a. Variablennamen und auch void setup(void).
Code:#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
// Version 0.0.3
const char* ssid = "WLAN";
const char* password = "0.0.3";
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;
}
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);
}
}
Irgendwas ist schief gegangen. Muss noch mal gucken.
Noch mal:
Wenn das Muster geändert wird und es wird mit Change:Ok übertragen, dann werden die Farben der Buttons zurückgesetzt.
Wenn das Muster gelöscht wird, passiert das, was bei Änderung geschieht, Learn und Detect müssen dann neu aktiviert werden.
Nicht so?
Soll der Status immer stehen bleiben, für isLearn, isDetect und isSave, sowie isReset?
Dann musst Du Dich um den Status dieser Buttons selber kümmern, denn irgendwann muss der wieder zurückgesetzt werden (wenn irgendein Button geklickt wird, werden die andern auch zurückgesetzt).
Status muss nur für Detect und Learn gesetzt bleiben, je nachdem, was zuletzt geklickt wurde und wie es auch vom Programm selber geändert wurde (z.B. bei Save erfolgt immer zuerst ein Wechsel zu modeDetect, das selbe bei Reset)
Auch automatisierte NN-Routinen können später den Learn/Detect-Mode zwischendurch ändern.
Jede Änderung wird aber immer bei
modeDetect
modeLearn
im Programm aktualisiert.
Von sich aus dürfen andere Button-Clicks den Detect/Learn-Status nicht ändern, also auch nicht die Farbe der Learn/Detect-Buttons.
die Farbe aller anderen Buttons ist unwichtig, hier bleibt nichts gespeichert, sie sollen also immer grau bleiben.
- - - Aktualisiert - - -
die Variablen heißen jetzt auch anders:
toSave,
toDetect,
toClear,
...
daher bitte jetzt bei meinem eigenen Code verbessern!
Ich habe Deinen Code geändert, aber nicht ausprobiert:
Ich habe das hier nochmal, wie es bei mir funktionierte:Code:#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
// Version 0.0.3
const char* ssid = "WLAN";
const char* password = "0.0.3";
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 = 0;
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(void) {
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; for(int i=0; i<(tableWidth*tableHeight); i++) matrix[i] = 0;} else {toClear=0; toChange=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++;
}
/* //Status aller Buttons zurücksetzen, wenn das Muster mit Change:Ok geändert wurde
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(void) {
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);
}
}
:!: Anhang 34442
Teile des Programms sind auskommentiert, also nicht entfernt, falls man die Funktion doch wieder ändern will.
Ich habe weitestgehend Verständnis, für die Änderungen. Aber irgendwann blicke ich dann durch meinen eigenen Code nicht mehr durch,
weil Du Änderungen drin vornimmst.
MfG
leider nein,
wenn das Programm den mode ändert (z.B. bei Reset), dann wird dir Learn-/Detect-Buttonfarbe nicht aktualisiert, sondern grau gemacht.
und wenn man Clear drückt, und dann auf OK, dann wird das komplett gelöschte Feld nicht übertragen, sondern das alte, vorherige.
Aber auch nach OK wird immer noch die Farbe von Detect/Learn auf grau zurückgesetzt, das darf auch nicht sein, denn hier werden Learn/Detect-Status ja überhaupt nicht geändert.
Und bitte keine zip-Anhänge!!
Teste es mal selber aus!
Man erkennt es am einfachsten, wenn man die letzten untersten Felder verändert.
Im Serial Monitor werden die Buttonclicks auch angezeigt,
dann das aktuell übertragene Keypad-Feld
und ebenfalls der jew. aktuelle, neu gesetzte Learn/Detect-Mode.
mein ursprünglicher Button-Clear Code ist übrigens inzwischen auskommentiert., daher wird Button Clear-Click nicht mehr seriell angezeigt
- vlt kannst du es für deine Änderungen wider mit verwenden:
Code:/*
if(toClear) {
Serial.println((String)"toClear="+toClear);
memset(matrix , 0, sizeof(matrix));
toClear=0;
}
*/
- - - Aktualisiert - - -
Deine Version im Anhang hat nicht meine Änderungen mit übernommen, ich kann es jetzt nicht mehr genau so laufen lassen.
Bitte verwende immer meine Änderungen mit und verändere bitte immer nur meinen geposteten Code samt Versions-Nummer, sonst kommt alles durcheinander!
Insb. die loop solltest du immer mit verwenden, denn hier läuft der Serial Monitor zum Debuggen, aber auch in setup ist was geändert, und zusätzlich gibt es weitere Variablen.
Der Code wächst ja immer weiter...
Wenn du nicht mehr durchblickst, starte nochmal bei Version 0.0.2
https://www.roboternetz.de/community...l=1#post655984
Zitat:
Zitat von HaWe
Neeee, das ist keine gute Idee! *lol*
Also ich programmier ja quasi ein Modul, das hat eine Schnittstelle.
Die kannst Du gerne benutzen, aber nicht den internen Code des Moduls umschreiben! :)
Für mich ist im Modul wichtig, dass isChange auch isChange bedeutet. Das kann ich zwar toChange ändern, aber nach dieser definition dürfte sich dann in meinem Modul der Pufferinhalt (matrix) nicht ändern.
Ich spiegele den Status wieder, nicht das, was außerhalb des Moduls damit mal passieren soll.
Aber ich wollte diesmal nicht so sein, drum hab ich es so geändert, wie Du es Dir vorstellst, obwohl Du den Modulcode nicht schreibst - sonst brauch ich das ja nicht machen.
Ich schau nochmal rein....
Ich orientiere mich jetzt mal daran, was Du geschrieben hast:
Zitat:
wenn das Programm den mode ändert (z.B. bei Reset), dann wird dir Learn-/Detect-Buttonfarbe nicht aktualisiert, sondern grau gemacht.
und wenn man Clear drückt, und dann auf OK, dann wird das komplett gelöschte Feld nicht übertragen, sondern das alte, vorherige.
Aber auch nach OK wird immer noch die Farbe von Detect/Learn auf grau zurückgesetzt, das darf auch nicht sein, denn hier werden Learn/Detect-Status ja überhaupt nicht geändert.
wenn das Programm den mode ändert (z.B. bei Reset), dann wird dir Learn-/Detect-Buttonfarbe nicht aktualisiert, sondern grau gemacht
aktueller Status bei mir:
LEARN und DETECT bleiben immer Rot, egal, was passiert / gedrückt wird
.
.
.
und wenn man Clear drückt, und dann auf OK, dann wird das komplett gelöschte Feld nicht übertragen, sondern das alte, vorherige
aktueller Status bei mir:
Das Feld wird gelöscht und bleibt gelöscht.
Falls es da Mißverständnisse gibt, kann ich ein Video machen (zwar schwierig alleine, aber vielleicht bekomme ich es hin) zum Anschauen.
Hat geklappt, hier das Video
https://youtu.be/yWqrUk5nDK4
MfG
.
ich habe ja dein Modul verwendet, aber auch mein Code außen rum ändert sich mit, nachdem du dein Modul angepasst hast.
es muss also immer alles per Handshake gehen:
deine Änderungen
meine neuen Änderungen
deine Änderungen meiner neuen Änderungen
....
usw.
auch setup und loop samt Variablen und Zusatzfunktionen werden ja ebenfalls weiterentwickelt.
Nur eine Kleinigkeit: aber z.B. in setup() sollte Serial als erstes gestartet werden, danach delay(1000), damit man auch WLAN und webserver seriell debuggen kann.
Am besten, du passt bei deinen Änderungen dann auch die Versionsnummer an.
- - - Aktualisiert - - -
PS,
bitte ändere nicht deine oberen Posts, wenn ich bereits darauf geantwortet habe, denn ich lese normalerweise oben nicht mehr nach.
das mit den zip Files macht auch keinen Sinn, bitte immer "Klartext"-Code.
der letzte Klartext-Code, den ich verwenden konnte, war der hier
https://www.roboternetz.de/community...l=1#post656003
allerdings sollte er Versionsnummer 0.0.4 tragen nach deinen Änderungen.
Er war aber noch fehlerhaft, wie beschrieben.
Videos bringen nichts, das kann ich nicht recht erkennen.
- - - Aktualisiert - - -
PPS,
Ergänzung, nach deiner Änderung:
mein Programm ändert (auch) intern den Lern/Detect-Modus, ohne dass ein Button gedrückt wurde.
Auch dann muss es das Panel erkennen und den neuen Modus rot kennzeichnen.
Ich sehe nicht, ob Du schon geantwortet hast. Kannst ja auch mal 15min warten, ob sich mein Beitrag noch ändert.
Leider fallen immer wieder noch mehr Sachen ein, wenn ich eigentlich schon fertig geschrieben habe. ;)
MfG
- - - Aktualisiert - - -
Bevor wir jetzt weiter machen, warte ich, bis das Video hoch geladen ist, dauert noch ca. 25min.
Dann kannst Du mal schauen, und wir können uns verständigen. Gerne auch dann mit Angabe der Position (mm:sec) im Video.
MfG
- - - Aktualisiert - - -
Was die Änderungen und das Weiterentwickeln angeht:
Ich habe den Code extra optisch gekapselt, dass man die Module erkennt und einfach austauschen kann.
Ich wollte mir das Drama jetzt mit den LIBs "*.h" etc. ersparen, weil ich darin noch ungeübt bin.
Daher sollte es einfach sein, auch in einem riesigen Quelltext, diese beiden Sachen zu finden und auszutauschen.
Da muss man nicht jedesmal den gesamten Quelltext über's Forum schicken - dachte ich mir so.
ich kann nicht deine Änderungen in meinen Code einarbeiten, wenn du meine vorherigen Änderungen nicht ebenfalls mit übernommen hast.
Es sind oft vielfältige Änderungen, hier und da.
bitte auch nicht einen Post nachträglich ändern, sondern zusätzlich antworten.
- - - Aktualisiert - - -
drücke mal die "Learn" Taste: Learn wird rot, das stimmt;
und dann die "Save" Taste
und schau, ob sich die Farbe von Learn und Detect Button ändern
Das müssen sie nämlich (Detect->rot und Learn->grau)
das selbe bei Reset.
guck bitte auch warum: nämlich was da in loop() und im Serial Monitor passiert.
- - - Aktualisiert - - -
ich beziehe mich auf Klartext-Code in https://www.roboternetz.de/community...l=1#post656003
(bei dir Version 0.0.3, eigentlich aber Version 0.0.4)
Da Du oben/vorher nicht mehr liest, schreibe ich es nochmals hier, dass das Video hochgeladen ist:
https://youtu.be/yWqrUk5nDK4
MfG
- - - Aktualisiert - - -
Ich brauche Deine Änderungen nicht übernehmen. Du sollst nichts an meinem Code ändern. Machst Du das nicht, muss ich es auch nicht übernehmen.Zitat:
Zitat von HaWe
Das erschwert die Zusammenarbeit ... leider ... ich suche mir das auch nicht aus.
In einer Firma mit 30 Programmierern wäre das auch nicht anders möglich. Da verlässt Du Dich auf den Code des andern Kollegen und benutzt die Schnittstelle,
dafür heißen die Teile so (gut, jetzt haben wir hier keine Eindeutige, aber ich habe mich sehr bemüht, die Variablen, die nach außen hin zu interessieren haben,
ganz nach oben zu stellen und habe sie kommentiert (damit wir es einfacher haben, in Deutsch). Und wenn was an dem Modul des Kollegen funktionell nicht passend
ist, teilt man das dem mit und er ändert das demnächst. Aber man nimmt nicht seinen Code, ändert den, gibt ihm den zurück und sagt: übernimm diese, meine Änderungen,
die ich angebracht habe.
Ich schaue gleich weiter ...
MfG
.
um es nochmal zu verdeutlichen:
der Farbwechsel darf nicht stattfinden, weil ein Button im Formular gedrückt wurde,
sondern einzig und allein, weil im Code steht
modeDetect=1/0
oder
modeLearn=1/0.
Ich muss deinen Code ändern können, denn dein Code muss auf meinen Code passen und reagieren.
Ich brauche deinen Code auch nicht als unveränderliche Schnittstelle, sondern als integralen Bestandteil MEINES Codes.
- - - Aktualisiert - - -
zum Video:
man sieht nach Druck auf Clear nicht, was im Serial Monitor passiert, da wird der Fehler nämlich offensichtlich!
markiere die beiden letzten Felder,
drücke OK,
kontrolliere im Serial Monitor.
drücke Clear, drücke OK,
kontrolliere im Serial Monitor:
hier sind immer noch die letzten 2 Felder markiert.
es dürfen auch nicht sowohl Learn als auch Detect Button gleichzeitg beide rot oder beide grau sein, bedingt durch die Variablen
modeLearn und modeDetect.
GGf. poste bitte deinen neuen Code samt meiner Ergänzungen (Version 0.0.5)
Das weiß ich nicht, warum das passiert.Zitat:
drücke mal die "Learn" Taste: Learn wird rot, das stimmt;
und dann die "Save" Taste
und schau, ob sich die Farbe von Learn und Detect Button ändern
Das müssen sie nämlich (Detect->rot und Learn->grau)
Fakt ist: Du kannst NICHTS eigenständig zum Browser schicken, der das dann ausführt.
Du bist immer drauf angewiesen, dass der User eine Aktion im Browser ausführt, worauf reagiert werden kann.
Du musst wissen, welche Funktionalität da sein soll. Das meiste davon werde ich in meinem Modul einbauen können.
Dass also bestimmte Buttons bestimmte Farben bekommen. Habe ich gemacht.
Irgendwo hast Du doch geschrieben, der Status der Buttons darf sich nicht ändern. Oder so ähnlich.
Wie soll das dann jetzt gemacht werden?
Da musst Du jetzt eine Wahrheitstabelle erstellen, wo die Abhängigkeit der Buttons draus hervorgeht.
Das so wild dort rein zu programmieren, führt ins Chaos und zu nicht funktionierendem Code. Da jagt dann ein
Problem das andere und die Katze beißt sich am Ende in den Schwanz ... und es vergehen Stunden um Stunden dabei.
Und deswegen werde ich dann auch die Variablen zurückändern, weil sonst die Logik in meinem Code hinten und vorne
irgendwann nicht mehr stimmt und ich nicht mehr weiß, was an welcher Stelle mit welcher Variable gemeint ist.
ok .... so weit
MfG
Du scheinst nicht zu verstehen, wann sich ein modeStatus ändert und wann nicht und wann und wie darauf die Button-Farbe zu reagieren hat.
Auch scheint dein Code nach Clear und OK die falschen Were zu übertragen (wie beschrieben).
Aber ok, wenn das so ist, dass der Browser nicht Aktionen des eigenständigen, automatischen Codes ebenfalls anzeigen kann, dann macht das ganze keinen Sinn.
Und wenn du meine Änderungen nicht übernimmst und passend weiter verarbeitest, auch nicht.
Dann kann ich aber dein jetziges html ButtonPad auch nicht fürs NN verwenden.
Antwort: neinZitat:
Zitat von HaWe
Um dem Wirrwarr zu entgehen, habe ich mich nun noch einige Zeit
hingesetzt und es etwas durchsichtiger gemacht, sowie geändert.
Wenn das sinnvoll weiter verfolgt werden soll, ist das notwendig.
Ich habe das alles in eine Datei gepackt:
:!: Anhang 34446
und in noch eine:
:!: Anhang 34447
MfG
- - - Aktualisiert - - -
Zitat:
Zitat von HaWe
Du wolltest, dass ich etwas in HTML mache. Habe ich getan. Zudem gebe ich mir alle Mühe und mache mir viele Gedanken,
wie wir das in den Griff bekommen, dass einerseits auf die User-Aktionen reagiert und die HTML-Datei entsprechend versendet wird
und andererseits Du aber in die Lage versetzt wirst, darauf Einfluss zu nehmen.
Worauf Du keinen Einfluss nehmen kannst: auf den Status, ob und was für einen Button der User angeklickt hat.
Deshalb auch auf diese Variablen nicht. Du kannst sie auslesen, aber nicht deren Namen ändern. Du kannst sie auch
überschreiben, was aber keinen Sinn macht. Sie sollen nur dazu dienen, dass Du in Erfahrung bringen kannst, ob und was der User
will.
Ich habe weitere Variablen eingeführt, die Dir Kontrolle und Einfluss erlauben. Du kannst nun Einfluss nehmen, ob der Inhalt der
neuen Variablen stateLearn und stateDetect - abhängig von der Nutzeraktion -geändert wird oder nicht und kannst
diese Variablen selbst ändern, darüber wird auch die Farbe der Buttons bestimmt, damit der Status dieser Variablen (Buttons)
für den Nutzer optisch ersichtlich ist.
Ich hoffe, dass wir damit ein gutes Stück besser voran kommen!
MfG
- - - Aktualisiert - - -
Wenn Du sonst für Buttons noch einen festen Status brauchst, der eben nicht abhängig vom User-Klick geändert wird, sondern für Deinen weiteren Programmablauf erhalten bleibt, solltest Du diese Variableninhalte in für Dich brauchbare Variablen, deren Namen Du dann selbst in Deinem Code bestimmen kannst, kopieren/übernehmen.
zip Anhänge bringebn nichts, besser man kann es dirket lesen, um sich darüber zu verständigen!!
Und es muss vollständiger Code sein!! (Komplettes Program!!)
ich will versuchen, dir noch mal den Grund zu erklären:
als reines Keypad ist die Website grundsätzlich OK,
und Zusatzbuttons zur Steuerung funktionieren grundsätzlich auch.
Was die Buttons für die Zustands-Modi angeht, so müssen die allerdings angezeigt werden, und hier kommen zu
Detect, Training
noch mindestens 2 weitere dazu: Upload und Pause,
und zwischen diesen Zuständen wird hin- und her geschaltet (immer nur 1 davon ist aktiv).
Diese Zustandsmodi werden allerdings auch vom laufenden Programm selbstständig, automatisch gesetzt und geändert, nicht nur vom User auf der Website, und wenn man neue Daten eingibt, muss man wissen, in welchem Zustand das Programm gerade ist (Zustandsautomat).
Wenn das über die Website nicht geht (Farbänderung der entspr. Buttons ,oder ggf eine Meldezeile), dann muss dies auf einem Display erfolgen und über GPIO-LEDs.
Mein M3 Due früher hatte viel RAM (mehr als der esp8266), genügend GPIOS (70), ein 2,8"" Farb-Display und konnte MT, darüber ging es, war aber per Menüsteuerung trotzdem sehr verschachtelt.
Mein ESP8266 hat nicht genügend freie Pins, eine SD-Karte braucht 4, und mein i2c-OLED 2 weitere, außerdem ist dieses eigentlich zu mickrig zur autonomen Steuerung: Hier bleiben also dann schon gar keine GPIOs mehr übrig für LEDs und Taster.
Fazit:
wenn man eine html-Website nicht auch als Dashboard zur Programmstatusanzeige verwenden kann, braucht man einen anderen Prozessor mit WiFi, mehr GPIOs, zusätzlichen GPIO-Tastern und einem großen TFT, und das kann dann nur ein ESP32 oder ein Raspi sein, und beide können ja auch MT.
Darüberhinaus muss ich in der Lage sein, Variablennamen zu ändern, wenn es nötig ist.
isSave ist missverständlich, da es nichts "ist", sondern nur einen btn-press signalisiert, wodurch etwas getan werden soll.
eigentlich wäre dann sogar etwas anderes wie btn_Save_press besser, analog auch btn_Clear_press usw., damit der Code später unmissverständlich bleibt.
Zusätzlich muss ich die Reihenfolge und Anordnung der Buttons samt ihrer Variablen für die Zwecke der NN-Steuerung ändern können, und das muss dann so bleiben.
Dein letzter zip Anhang ist wie geesagt nicht nutzbar für mich, da er nicht meinen eigenen Code samt Test- und Debugroutinen mit eingearbeitet hat und noch nicht einmal lauffähig ist. Auch hast du die Variablennamen zurück-geändert, wodurch sie jetzt nicht mehr zu meinem Testcode passen.
Ich werde daher wschl auf Version 0.0.2a zurückgehen, ohne Farbänderung der Buttons (denn das geht ja eh nicht programmseitig) und muss sehen, ob ich Teile der Buttons auf ein TFT/OLED-Display-Menü übertrage, samt Zustandsanzeige.
Am WE jetzt bin ich viel unterwegs, höchstens zwischenzeitlich mal am PC (aber dann ohne ESP8266) wschl also erst im Lauf der kommen den Woche.
Ob ich das ganze also hinkriege, dass auch du das NN am esp8266 benutzen kannst, ist ziemlich unsicher, vermutlich vlt eher nicht, ich selber würde meinem Adafruit Feather ESP32 mit 3,5" TFT bessere Chancen einräumen, und selbst das wird viele Wochen Arbeit bedeuten.
- - - Aktualisiert - - -
was allerdings schön wäre: ein Bugfix für Version 0.0.2a, sodass ein Clear-Press nach Daten-OK/submit sofort das Keypad leert, nicht erst nach 2x, und es auch nicht nur scheinbar leert wie bei Version 0.0.3/4:
sondern nach XXX Daten OK/submit, dann Clear-Press und dann unmittelbarem Click auf OK/submit dann auch wirklich sofort ein leeres Feld übertragen wird und nicht doch noch mal der vorher ungelöschte Inhalt.
Code:#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
// Version 0.0.2a
const char* ssid = "WLAN";
const char* password = "1234567";
ESP8266WebServer server(80);
//-----------------------------------------------------
//HTML und Daten für das Eingabe-/Ausgabefeld
//einfügen im globalen Scope
//-----------------------------------------------------
//erstellt von (c): Moppi @roboternetz.de
//-----------------------------------------------------
//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
volatile static bool toChange = 0;
volatile static bool toLearn = 1;
volatile static bool toDetect = 0;
volatile static bool toReset = 0;
volatile static bool toSave = 0;
volatile static 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\" type=\"submit\" value=\"Learn\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"learn\"></form>";
String s5_2="<form method=\"get\"><input id=\"bu\" 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
//-----------------------------------------------------
memset(matrix , 0, sizeof(matrix));
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;
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++;
}
}
}
//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+s5_2+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);
}
}
Wie schon früher erwähnt, kann noch ein Reload
der Seite vom Browser aus veranlasst werden.
Eine Möglichkeit habe ich zunächst eingebaut.
So, wie ich jetzt lese, geht es ohne wohl nicht.
Die neue Version ist: 20191102.1
Zwei neue Variablen sind hinzugekommen:
Code:
Variable: bool ifRefresh = 1;
Beschreibung: Refresh der Seite ausführen 0 = nein, 1 = ja
Ändern: darf geändert werden
Wirkrichtung: unidirektional, Programm -> Browser
---------------------------------------------------------------------
Variable: const int RefreshTime = 4;
Beschreibung: Zeit, nach der die Seite erneut abgerufen wird
Ändern: darf bei Programmerstellung geändert werden
Wirkrichtung: unidirektional, Programm -> Browser
:!: Anhang 34448
Ich weiß, Softwareentwicklung ist keine einfache Sache. Ablaufpläne haben wir hier noch gar nicht erwähnt,
aber eine Wahrheitstabelle für die Buttons wäre gut gewesen, dann hätte ich früher einen Überblick gehabt,
wie die wann reagieren sollen; hätte vlt. das ein oder andere mit einbauen können.
Falls Du das ausprobierst, bitte dran denken, dass die Steuerung des Seiten-Reload von Dir aktiviert oder
deaktiviert werden kann/soll/muss.
MfG
danke, aber mit dem zip kan ich nichts anfangen - ich weiß nicht was wo hin soll und was stattdessen raus muss.
Außerdem stimmen die Variablen-Namen nicht mit 0.0.2a überein.
Bitte kopiere es in meinen Sketch ver 0.0.2a hinein und poste es neu!
Danke!
ich teste den lauffähigen Code dann ASAP!
Meine Hilfestellung habe ich darin gesehen, bezüglich dieser Button-Pad-Geschichte
(ausgehend von Buttons mit LEDs) in möglichst kurzer Zeit, etwas zu erstellen,
das platzsparend im Quelltext unterzubringen und einfach dort austauschbar ist.
Letzteres, um die gute Wartbarkeit des Codes zu gewährleisten.
Dass das Produkt hier nicht das Ende der Weiterentwicklung darstellen muss,
sollte bewusst sein. Das betrifft auch die eingesetzten Techniken zur Datenübertragung,
seitens des Webbrowsers.
Modular und strukturiert vorzugehen, ist bei Teamarbeit unerlässlich, weil es
viel Zeit spart und das Projekt somit schnell voran bringt.
Der von mir vorgelegte Aufbau des Quelltextes ist zunächst experimentell, aber auch so
gewählt, damit das später in eine externe Bibliothek umgewandelt werden kann, wo aus
der Sache dann ein Objekt mit Methoden werden könnte.
Angesichts der Schwierigkeiten der Akzeptanz eines solchen Aufbaus / Vorgehens
sehe ich es aber als zu zeitraubend, zwei Quellcodes / Module zweier "Programmierer"
miteinander zu verquicken / ineinander zu verschachteln, so dass dann nur noch ein
größerer Quellcode da ist, mit vielen Bestandteilen, die mit der eigentlichen
Ausgangsaufgabe nichts zu tun haben. Wer soll den dann warten?
Der Quellecode liegt vor, ist einfach für Dich zu verstehen und daher steht es Dir frei,
das irgndwie anders in Deinem Programm umzusetzen oder zu integrieren.
Ob Du so eine Lösung aus technischer Sicht verwenden kannst, war von Anfang an fraglich
und muss(te) sich mit der Zeit herausstellen. Wissen kannst nur Du das, was Du dann für
Dein Vorhaben benötigst.
Ich werde an diesem Punkt nicht weiter daran arbeiten, sondern mich dann wieder anderen
Sachen zuwenden.
MfG
Moppi
es kann bei so speziellen Anforderungen wie für ein Dashborad samt User-Control und Monitor für ein NN IMO nur funktionieren, wenn der komplette lauffähige Code ständig überarbeitet wird, schrittweise und komplett -
erst wenn er komplett reibungslos funktioniert und alle Funktionen perfekt aufeinander abgestimmt sind und fehlerfrei und schnell genug miteinander funktionieren, kann man den html-Part auskoppeln und in eine eigenständige Lib auslagern.
Trotzdem vielen Dank bis hier hin, die Version 0.0.2b ist ja auch immerhin ein guter Anfang!
ich habe trotz alledem noch eine Verständnisfrage:
Wozu dient hier
in Zeile 115 die AnweisungCode:#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
// Version 0.0.2b
const char* ssid = "WLAN";
const char* password = "59467";
ESP8266WebServer server(80);
//-----------------------------------------------------
//HTML und Daten für das Eingabe-/Ausgabefeld
//einfügen im globalen Scope
//-----------------------------------------------------
//erstellt von (c): Moppi @roboternetz.de
//-----------------------------------------------------
//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
volatile static bool toChange = 0;
volatile static bool toLearn = 1;
volatile static bool toDetect = 0;
volatile static bool toReset = 0;
volatile static bool toSave = 0;
volatile static 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\" type=\"submit\" value=\"Learn\"><input id=\"un\" type=\"text\" name=\"bn\" value=\"learn\"></form>";
String s5_2="<form method=\"get\"><input id=\"bu\" 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.config(IPAddress(192, 168, 2, 99), IPAddress(192, 168, 2, 1), IPAddress(192, 168, 2, 1), IPAddress(255, 255, 255, 0));
WiFi.begin(ssid, password); //begin WiFi connection
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
//-----------------------------------------------------
memset(matrix , 0, sizeof(matrix));
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;
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++;
}
}
}
//toChange = 1;
//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+s5_2+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) {
while (millis() - timestamp >= 1000) {
sec++;
timestamp += 1000;
}
Serial.println(sec);
}
}
if (ic != matrix[n]) toChange = 1;
:?:
Wenn der Status von toChange allein vom ButtonClick auf Btn "Change:OK" abhängig sein soll, braucht man dann die Zeile trotzdem?
Kann man sie auch ohne if(...) immer sofort fest auf toChange = 1 setzen ?
Oder kann man sie auch komplett weglassen?
Alle diese Variablen zeigen an, ob Änderungen vorliegen:
An isChange kann man dies für das Eingabefeld (Matrix) ablesen, wird die Zeile "if (ic != matrix[n]) toChange = 1;" entfernt, ist das nicht mehr möglich.Code://Status, ob Änderungen vorliegen bool isChange = 0;
bool isLearn = 0;
bool isDetect = 0;
bool isReset = 0;
bool isSave = 0;
bool isClear = 0;
An isLearn kann man dies für den Button Learn ablesen.
An isDetect kann man dies für den Button Detect ablesen.
An isReset kann man dies für den Button Reset ablesen.
An isSave kann man dies für den Button Save ablesen.
An isClear kann man dies für den Button Clear ablesen.
Somit kann man nach jedem "Browserkontakt" feststellen, ob sich etwas geändert hat und wenn, was sich geändert hat. Man kann feststellen: was wollte der Benutzer.
Im Falle eines einfachen Refresh der Ausgabe im Browser (was ich durchaus von Anfang an, aus Erfahrung, einkalkuliert habe), will der Benutzer gar nichts, weil er keine Eingabe tätigt, weder über das Eingabefeld (Matrix) noch über die Buttons. Dann sollten alle oben genannten Variablen auf 0 stehen. Dennoch überträgt mein Programmcode den (eventuell geänderten) Inhalt der Matrix zum Browser, wo der dargestellt wird.
Durch das Umbenennen der Variablen von "is" nach "to" wird der Sinn der Variablen im Code verfälscht und infolge dessen dann vermutlich auch falsch angewendet, das Verständnis leidet darunter.
Mein Code übernimmt die bidirektionale Datenübermittlung zwischen Browser und nodeMCU, auf möglichst minimalistische Art. Ändert man daran etwas, ist diese Funktion nicht mehr sichergestellt.
Um daran nichts ändern zu müssen, gibt es die verschiedenen Variablen für die Steuerungsmöglichkeiten des Codes. Die Beschreibung dafür war anbei.
MfG
ja, sorry, deine Beschreibung verstehe ich aber nicht, weil ich generell html-Code und seine Funktionsweise nicht verstehe, insb. auch nicht, was Webserver oder Webclients oder Wifi-Server oder Wifi-Clients sind oder tun.
Ich bräuchte eher eine funktionelle, zweckgerichtete Erklärung, welche Codezeile welches Ergebnis an welcher Stelle für welche Variablen in meinem eigenen Programm erzeugt - in diesem Falle die Codezeile mit dem toChange (hier wäre etwas zu ändern bzw. auf etwas zu reagieren im laufenden Code der loop() ).
Habe meinen Beitrag nochmal geändert, um genauer auf die Frage einzugehen (hier nochmal als Auszug):
An isChange kann man dies für das Eingabefeld (Matrix) ablesen, wird die Zeile "if (ic != matrix[n]) toChange = 1;" entfernt, ist das nicht mehr möglich.
MfG
das macht es jetzt leider noch nicht klarer:
ich habe mal die Zeile
if (ic != matrix[n]) toChange = 1;
testweise auskommentiert und neu kompiliert: In der Tat reagiert jetzt der Browser nicht mehr auf Eingaben in der 10x10 Matrix.
Nun habe ich toChange=1 fest hinter die for Schleife gesetzt:
Hier registriert es nun die entspr. Eingaben (allerdings ändert sich das Laufzeitverhalten nach Druck auf die Clear-Taste)Code: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++;
}
}
}
toChange = 1;
"if (ic != matrix[n])" vergleicht den Inhalt des Arrays (Matrix) mit den Daten, die der Browser gesendet hat.
MfG
ja, das ist klar, aber warum soll er nur auf erkannte Änderungen reagieren und nicht "blind" alles neu übernehmen, egal ob eine Änderung erkannt wurde oder nicht?
Weil die Daten nicht immer gesendet werden, es wird das verwertet, was gesendet wird. Wird etwas nicht gesendet, ist es auch nicht geändert. Schau in die Browserzeile, dort siehst Du die übergebenen Parameter.
MfG
- - - Aktualisiert - - -
Nochmal anders:
Wenn die Daten für diese Matrix vom Browser gesendet werden, werden die übernommen. Aber es wird geprüft, ob die auch verändert wurden, dies zeigt isChange an.
Übernommen werden die Daten vom Browser hier: if (a == "") matrix[n] = 0; else matrix[n] = 1;
Auf Änderung geprüft hier: if (ic != matrix[n]) isChange = 1;
- - - Aktualisiert - - -
Du musst den Status nicht beachten, Du kannst die Daten auch jedesmal aus dem Array übernehmen, falls das einen Sinn ergibt!
dann ist das isChange für die Matrix also etwas anderes als das isChange für den Change:OK Button?
Oder hat der isCahnge-Button gar keine isChange Variable?
Dieser Button sendet schon immer das, was der User in der Matrix eingeben kann (also die Kreuzchen setzen). User setzt seine Kreuzchen und klickt den Button zum Versenden der Daten.
Beim ersten Mal stimmt das daher mit dem Buttonstatus überein.
Aber:
User klickt auf den Button, aus irgendeinem Grund auch zweimal hintereinander oder dreimal. Das wird dann abgefangen.
MfG
- - - Aktualisiert - - -
Warum der Change:Ok heißt, habe ich nie erklärt bekommen. Solche Buttons kenne ich nicht und so eine Bezeichnung ist auch vollkommen unüblich.
Falls Du damit verschiedene Sachen zum Ausdruck bringen willst, muss man mal schauen... Vielleicht muss man das dann auch auf zwei Buttons aufteilen "change" und "ok"
aha, dann müsste man wschl aber eher für die Events "Left-Click in die Matrix" und "Left-Click auf Change:OK-Button" verschiedene Signal-Variablen verwenden.
- - - Aktualisiert - - -
PS,
der "Change: OK" Button hieß früher nur "OK", das war aber missverständlich.
Was er machen soll:
Der Button soll signalisieren, dass man mit dem Herumklicken in der Matrix fertig ist und der aktuelle Zustand mit den jetzt zuletzt gemachten Änderungen übermittelt und dann weiter verarbeitet werden soll.
Alle vorherigen Klicks und Änderungen in der Matrix (inkl. "Clear"-Buttonclick) sind für das NN Programm eigentlich völlig unwichtig, sie müssen nur in der Matrix sichtbar sein ("X" oder " ");
das ist aber nur für den Benutzer wichtig, damit er sieht, was er bisher so gemacht hat, nicht aber fürs NN-Programm.
Erst nach "Change: OK"
(noch besser: "Matrix: submit")
sollen die Matrix-Daten ans NN-Programm gesendet und dann vom NN Programm in der loop() weiter verarbeitet werden.
Ja das ist Sinn und Zweck dieses Buttons gewesen. Wenn Änderungen der Matrix beim nodeMCU ankommen wird dies in "isChange" mit "1" markiert. Sind keine Änderungen da, wird das mit mit "0" markiert.Zitat:
Der Button soll signalisieren, dass man mit dem Herumklicken in der Matrix fertig ist und der aktuelle Zustand mit den jetzt zuletzt gemachten Änderungen übermittelt und dann weiter verarbeitet werden soll.
Daher kannst Du in Deinem Programm z.B. auch schreiben: bool toChange = isChange;
Ich habe es mal geändert, dass es zwei Variablen gibt: ChangeOk und ChangeM
neue Version: Anhang 34459
ChangeOk ist immer "1", wenn Daten mit diesem Button übermittelt wurden.
ChangeM ist nur "1", wenn die Daten der Matrix vom User auch geändert wurden.
edit:
die "neue Version" kann ich wieder nicht verwenden - deine jetzigen Änderungen passen nicht zu meiner Programmstruktur.
wie oft noch:
zip Anhänge bringen nichts, besser man kann es dirket lesen, um sich darüber zu verständigen, und es bringt nur ein vollständiges Programm etwas!.
(ich habe es als komplette Block-Änderung versucht, ergibt gefühlt 1000 Fehlermeldungen).
Dann habe ich es schrittweise versucht...:
isChangeM (Matrix) interessiert ja mein Programm (in loop()) wie gesagt auch gar nicht mehr, sondern nur isChangeOK (Button);
wenn ich allerdings jetzt isChangeOK wie bisher isChange abfrage, dann werden nun überhaupt keine Matrix-Daten mehr an loop() weitergegeben.
Ist also alles kompletter Murks im jetzigen Zustand: Ich brauche die kompletten Änderungen in meinem kompletten Programm.
Ich verstehe auch nicht, warum du dich so halsstarrig weigerst, sie in den lauffähigen Code einzubauen, wo es doch als losgelöstes Block-Schnipsel überhapt nichts nutzt!
Du kannst dann dort im Komplett-Programm aber gerne alle "toXXX" nach "isXXX) zurück-verändern.
- - - Aktualisiert - - -
PS:
der Change:OK Button muss IMMER die Matrix senden, auch wenn keine Änderungen in der Matrix vorgenommen wurden - er tut aber sowieso in jedem Falle überhaupt nichts (Auswertung der Variable "isChangeOK")!
Macht der ja auch.Zitat:
der Change:OK Button muss IMMER die Matrix senden
Und da er auch das in der bisherigen Version macht, was Du Dir vorgestellt hast, brauchst Du auch den geänderten Code nicht. Damit wird es in der Tat u.U. nicht einfacher. Obwohl Du im neuen Code, so wie Du es brauchst, dann nicht ChangeOk abfragst, sondern ChangeM, das hat dann eigentlich die Funktion, die Du benötigst. Weil aus isChange ist isChangeM geworden.
Ich habe den Verdacht, dass Du damit nicht richtig umgehst, warum auch immer.
Da mein 3D-Drucker aber heute unter Koprostase leidet, nehme ich mir mal meinen Code und ....
... dann wird ein Video bei rauskommen.
MfG
hast du nicht geschrieben, dass isChangeM die MatrixClicks abfragt? das ist aber nicht wichtig.
Wichtig ist nur, dass der Change:OK Button abgefragt wird (isChangeOK) und dann auf Abfrage von isChangeOK ohne wenn und aber den aktuellen Matrix-Inhalt übermittelt.
- - - Aktualisiert - - -
Ich habe eher den Verdacht dass DU den Code fürs NN in loop() nicht richtig umgesetzt hast.Zitat:
Zitat von Moppi
poste dann aber auch bitte den kompletten Code, damit ich ihn bei mir kontrollieren kann!
auf Abfrage von isChangeOK muss er folgendes machen (muss sich wie hier per Serial.print() kontrollieren lassen):
Code:void loop() {
if (isChangeOK ) {
Serial.println("new data:");
for (int i = 0; i < 100; i++) {
bufferArray[i] = (float)matrix[i];
Serial.println((String)i + ": " + bufferArray[i]);
}
isChangeOK =0;
}
//...
//...
}
Ich habe mal einiges ausprobiert und mir anzeigen lassen, um Missverständnisse zu vermeiden:
Was mir dabei aufgefallen ist:Code:meine Version: 20191102.1
Ausgangssituation:
isChange: 0
isLearn: 0
isDetect: 0
isReset: 0
isSave: 0
isClear: 0
stateLearn: 0
stateDetect:0
--------------------------------
Status nach Änderung der Matrix + Change:Ok
isChange: 1
isLearn: 0
isDetect: 0
isReset: 0
isSave: 0
isClear: 0
stateLearn: 0
stateDetect:0
--------------------------------
Status nach Learn
isChange: 0
isLearn: 1
isDetect: 0
isReset: 0
isSave: 0
isClear: 0
stateLearn: 1
stateDetect:0
--------------------------------
Status nach Detect
isChange: 0
isLearn: 0
isDetect: 1
isReset: 0
isSave: 0
isClear: 0
stateLearn: 1
stateDetect:1
--------------------------------
Status nach Reset
isChange: 0
isLearn: 0
isDetect: 0
isReset: 1
isSave: 0
isClear: 0
stateLearn: 1
stateDetect:1
--------------------------------
Status nach Save
isChange: 0
isLearn: 0
isDetect: 0
isReset: 0
isSave: 1
isClear: 0
stateLearn: 1
stateDetect:1
--------------------------------
Status nach Change:Ok, ohne Änderung der Matrix
isChange: 0
isLearn: 0
isDetect: 0
isReset: 0
isSave: 1
isClear: 0
stateLearn: 1
stateDetect:1
--------------------------------
Status nach Änderung der Matrix + Change:Ok
isChange: 1
isLearn: 0
isDetect: 0
isReset: 0
isSave: 1
isClear: 0
stateLearn: 1
stateDetect:1
Die Buttons Learn, Detect, Reset, Save und Clear setzen den Status aller anderen Buttons auf "0". Change aber tut das nicht.
Daher: Wenn eine Änderung von Dir registriert wurde, weil isChange == 1 war, muss isChange von Deinem Programm auf "0" gesetzt werden. Solang dies nicht geschieht, bleibt isChange (nach erfolgter Änderung) auf "1", bis Du es entweder löschst oder einer der anderen Buttons angeklickt wurde.
Zu stateLearn und stateDetect steht auch was in der Beschreibung. Wurden die zugehörigen Buttons angeklickt, bleiben diese Variablen auch so lange auf "1", bis Du sie änderst. Bei "1" erscheint hier der zugehörige Button im Browser dann in Rot.
- - - Aktualisiert - - -
Ich habe oben schon geschrieben, dass dies so funktioniert. Das hat immer so funktioniert. Siehe: https://www.roboternetz.de/community...l=1#post656202Zitat:
hast du nicht geschrieben, dass isChangeM die MatrixClicks abfragt? das ist aber nicht wichtig.
Wichtig ist nur, dass der Change:OK Button abgefragt wird (isChangeOK) und dann auf Abfrage von isChangeOK ohne wenn und aber den aktuellen Matrix-Inhalt übermittelt.
Nein! Du bringst gerade die Versionen durcheinander!
Ich hatte schon geschrieben: lass die neue Version 20191109 in Ruhe, nimm die Alte, die Du vorher auch hattest, die machte das, was Du willst. Ansonsten ist bei der Neuen aus "isChange" "isChangeM" geworden. Es sei denn, es interessiert Dich, ob der User auf Chanke:Ok geklickt hat, ohne dass sich etwas geändert hätte - dies spiegelt dann isChangeOk wieder (mit "1").
ich habe noch mehr Fehler entdeckt....
- - - Aktualisiert - - -
ja, es müssen offensichtlich neue Funktionen für Matrix-Änderung und ChangeOK ButtonClick hinzukommen.
falsch:
es darf immer nur bei einem Event die entsprechende Variable auf 1 gesetzt werden, ALLE ANDEREN dürfen nicht geändert werden in ihrem Zustand.
also bei
MatrixClick: nur isChangeM =1
ChangeOK Btn: nur isChangeOK=1
Clear Btn: nur isClear=1
Save Btn: nur isSave=1
Learn Btn: nur IsLearn=1
usw.
auch
stateLearn
stateDetect
darf hier nicht verändert oder gesetzt werden, das muss in loop() passieren
auch alle anderen Variablen-Änderungen dürfen nur in loop() geschehen.
Ich hatte Dich schon gebeten, eine Wahrheitstabelle zu erstellen, dann hätte ich das evtl. eingebaut. So, wie es jetzt ist, funktioniert es aber auch. Du kannst die Variableninhalte in Deine eigenen Variablen übernehmen und dann - je nach Status - die auch ändern, wie Du möchtest oder eben auch nicht ändern, dass ein Status erhalten bleibt.
Dazu habe ich hier was geschrieben: https://www.roboternetz.de/community...l=1#post656019Zitat:
auch
stateLearn
stateDetect
darf hier nicht verändert oder gesetzt werden, das muss in loop() paassieren
Zitat:namentlich: ifLearn und ifDetectZitat:
Ich habe weitere Variablen eingeführt, die Dir Kontrolle und Einfluss erlauben. Du kannst nun Einfluss nehmen, ob der Inhalt der
neuen Variablen stateLearn und stateDetect - abhängig von der Nutzeraktion -geändert wird oder nicht und kannst
diese Variablen selbst ändern
Nochmal aus der Beschreibung:
Code:---------------------------------------------------------------------
Variable: bool stateLearn = 0;
bool stateDetect = 0;
Beschreibung: Status der Buttons und deren Farbe
Ändern: Ändern beeinflusst die Farbe der Buttons, im Browser
Wirkrichtung: bidirektional, Programm <-> Browser
(wenn ifDetect/ifLearn = 1, dann wird stateLearn /
stateDetect auf "1" gesetzt, wenn der zugeh. Button
im Browser angeklickt wurde)
Wirkrichtung: unidirektional, Programm -> Browser
(wenn ifDetect/ifLearn = 0 und wenn der zugeh.
Button im Browser angeklickt wurde, ändern sich
stateLearn / stateDetect nicht)
nein, das ist nicht gut mit stateLearn und statedetect, das muss hier aus dem html code erst mal raus.
erstmal muss der Rest funktionieren.
edit: eine Wahrheitstabelle?
was soll die bringen?
Es gibt keine Wahrheitstabele, es sollen nur immer aktuelle Buttonclicks per Variablen gesendet werden, der Rest bleibt wie er ist!!