Ich suche jetzt schon den ganzen Abend nach einem Sketch,
mit dem ich meinem Arduino "Befehle" (Zahlenwerte von 0-400) senden kann,
indem ich sie auf einer Webseite (die des ESP8266) eingebe.
Andere Beispiele habe ich zu genüge gefunden,
dieses, für mich offensichtliche, jedoch noch nicht.
Das (oder der?) ESP soll einfach nur die Eingabe der Befehlszeile im seriellen Monitor ersetzen.
Nicht mehr und nicht weniger...
Könnt Ihr mir weiterhelfen?
Links zu nem Beispielsketch wären super,
gerne aber auch Hinweise oder Anregungen mein Vorhaben betreffend.
Der ESP8266 hat keine "Webseite", es sei denn, du programmierst eine. Und dann musst du eben eine Routine machen,die die eingegebene Daten per seriell rausschickt.
Mit der Originalen FW ist das so direkt nicht möglich, da must du im Arduino alles programmieren, also Webseite, Empfangsroutinen, etc.
Ich suche jetzt schon den ganzen Abend nach einem Sketch,
mit dem ich meinem Arduino "Befehle" (Zahlenwerte von 0-400) senden kann,
indem ich sie auf einer Webseite (die des ESP8266) eingebe.
Alternativ, oder erweiternd, zu oben genannten Varianten...
Variante 1:
Auf den Arduino verzichten und den ESP alles machen lassen.
Variante 2:
Den Arduino als I2C Slave, des ESP, laufen lassen
Sozusagen degradieren.
Es muss ja auch keine Webseite sein, die Zahl könnte ja auch per GET übertragen bzw. empfangen werden.
In einem Beispiel lief es so. (192.168.178.54/gpio/0)
Um damit einen der beiden Pins am ESP zu schalten.
Wir möchten jetzt aber nichts am ESP schalten, sondern die Zahl per Tx->Rx an den Arduino schicken.
Der ESP alleine hat zu wenig Pins (zumindest dieser hier).
Endgültig könnten wir schon komplett auf ESP umsteigen, dass soll aber hier jetzt nicht die Lösung sein.
I2C Slave schaue ich mir mal an, genauso den CMDMessenger
Nach den Beispielen in der IDE oder die die ich im Netz gefunden habe,
hätte ich nicht gedacht, das unsere gewünschte Funktion so viel aufwändiger ist.
Es muss doch nur der GET-String empfangen und weitergeleitet werden.
Die Zahl kann ja auch auf dem Arduino aussortiert werden, wobei da ja eig. egal ist.
Wenn du die AT Firmware auf dem ESP beibehalten willst, dann tue das.
Steuere den ESP über den Arduino.
Werte den GET String auf dem Arduino aus.
Wenn du den ESP mit einer eigenen Firmware ausstatten willst, welche das ganze HTTP Gedöns selber abhandelt, dann tue das. Werte den GET String auf dem ESP aus. Sende nur den Wert zum Arduino.
Irgendwann wirst du dich für einen Weg entscheiden müssen. Und dann ziehe es durch.
Das WiFi Kochbuchbeispiel habe ich versucht zu verstehen, ist aber sehr komplex.
Ich hoffe es geht etwas einfacher.
Daher nochmal was wir gerne hätten:
Bislang steuern wir unser Skript (ist erstmal nur n Testskript) auf dem Arduino über Serial.read().
Mit Zahlen zwischen 001 und 999, könne wir einen Motor steuern.
Und jetzt möchten wir genau das gerne über WIFI machen.
Dafür soll sich der ESP in unser WLAN einwählen.
Die IP könne wir ja erstmal über die Fritz.Box herausbekommen.
Ob wir jetzt den Browser aufrufen und IP/001 schreiben,
oder es über die Eingabeaufforderung machen müssen,
ist erstmal egal.
Setze auf dem ESP einen Server auf, welche deine WLAN Anfragen entgegen nimmt und den Wert zwischen 001 und 999 Über die Serielle Schnittstelle zum Arduino sendet.
Die Webseiten-Generierung wie im Post #6 verlinkt habe ich auch noch nicht probiert.
Ist mir auch momentan zu komplex. Versteh ich nicht.
Der hier läuft:
/*
* This sketch demonstrates how to set up a simple HTTP-like server.
* The server will set a GPIO pin depending on the request
* http://server_ip/gpio/0 will set the GPIO2 low,
* http://server_ip/gpio/1 will set the GPIO2 high
* http://server_ip/gpio/3 will set the GPIO0 low,
* http://server_ip/gpio/4 will set the GPIO0 high,
* server_ip is the IP address of the ESP8266 module, will be
* printed to Serial when the module is connected.
*/
#include <ESP8266WiFi.h>
const char* ssid = "deine SSID";
const char* password = "dein Passwort";
// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80); //Port
void setup() {
Serial.begin(115200);
delay(10);
// prepare GPIO2
pinMode(2, OUTPUT);
digitalWrite(2, 0);
// prepare GPIO0
pinMode(0, OUTPUT);
digitalWrite(0, 0);
// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
// Start the server
server.begin();
Serial.println("Server started");
// Print the IP address
Serial.println(WiFi.localIP());
}
void loop() {
// Check if a client has connected
WiFiClient client = server.available();
if (!client) {
return;
}
// Wait until the client sends some data
Serial.println("new client");
while(!client.available()){
delay(1);
}
// Read the first line of the request
String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();
// Match the request
int Pin2;
int Pin0;
if (req.indexOf("/gpio/0") != -1)
Pin2 = 0;
if (req.indexOf("/gpio/1") != -1)
Pin2 = 1;
if (req.indexOf("/gpio/2") != -1)
Pin0 = 0;
if (req.indexOf("/gpio/3") != -1)
Pin0 = 1;
//else {
// Serial.println("invalid request");
// client.stop();
// return;
//}
// Set GPIO2 & GPIO0 according to the request
digitalWrite(2, Pin2);
digitalWrite(0, Pin0);
Serial.println(req.substring(17, 19));
Serial.println(req.substring(20, 22));
Serial.println(req.substring(29, 31));
Serial.println(req.substring(39, 40));
client.flush();
// Prepare the response
//String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now ";
//s += (val)?"high":"low";
//s += "</html>\n";
// Send the response to the client
//client.print(s);
//delay(1);
//Serial.println("Client disonnected");
// The client will actually be disconnected
// when the function returns and 'client' object is detroyed
}
Einfach deine SSID vom Router und Passwort eingeben.
LED an GPIO0 & GPIO2 anschließen.
Dann kannst du mit http://server_ip/gpio/1 usw deine LED ansteuern.
Zusätzlich lese ich aus dem Empfangenen mit substring ein paar Zeitwerte aus, welche ich später in mein Programm integrieren möchte: 192.168.60.1/AnfangsZeit/18:00/Dauer/15/Umlauf/4
Ich möchte dann später evtl. auch den Arduino UNO/Mega weglassen und alles auf dem ESP laufen lassen. Dann muß ich meine Daten nicht erst kompliziert an den Uno weiterleiten (Fehlerquellen vermeiden).
Wenn auf dem ESP eh die Arduino-Software läuft...
Werde aber wohl den NodeMCU nehmen, weil dort mehr Anschlüße rausgeführt sind, schon USB dran ist & mit 5V betrieben werden kann.
Bin aber auch noch am Probieren & Zusammenpuzzeln der Möglichkeiten