Arduino mittels ESP über Webseite steuern

Hallo

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.

Gruß Kolja

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.

Variante 3:
Auf dem Arduino, dem ESP und vielleicht auch auf dem PC ein Kommano Interface bauen. Oder dieses verwenden
http://playground.arduino.cc/Code/CmdMessenger

DiesenVarianten ist gemeinsam, dass man sich nicht auf einem AVR mit dem Netzwerkgedöns rumschlagen muss

Hallo und danke für die beiden Antworten

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.

Gruß Kolja

Ich verstehe deine Probleme nicht......

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.

Wieso überhaupt GET ?

Wenn kein Browser im Spiel ist, sondern ein eigens Programmierter Client, muss ich mich doch nur an meine eigenen Regeln halten.

Daten aus einer ESP gernerierten Webseite senden? Da hab ich mal was gesehen.

Schau dir mal das hier an. Ist ne Menge Code - muß man sich eine Weile damit beschäftigen...

@stoni99: Hast du das jetzt hingekriegt, dass es zuverlässig läauft?

@kolja82: Beschrei mal genauer, was du im Endeffekt erreichen willst.

@stoni99
würde mich auch mal interessieren, weil ich hab leider probleme damit, siehe hier:
http://forum.arduino.cc/index.php?topic=358900.90

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.

Vielen Dank für die Hilfe

Kolja

Dann tue das so!

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.

Hä, ja aber, genau das war doch meine Frage:

Ob da jemand ein Beispiel für mich hat?

Irgendwie drehen wir uns im Kreis.

Hä, ja aber, genau das war doch meine Frage:

Gut, dann habe ich die Frage ja wenigstens schon mal verstanden!
Oder?

Jetzt müsste ich noch wissen, wo es klemmt!

Du hast einen Ardiuno!
Fein.

Du hast einen ESP!
Auch fein.

Und jetzt schreibst du für den ESP einen rudimentären Webserver, welcher eine Zahl ausgibt.

Ob da jemand ein Beispiel für mich hat?

Für deine Konkrete Anwendung?
Ich nicht.
Aber allgemein, für Webserver, ja!

Das sollte sich schon auf deinem Rechner befinden!
Nutze es!

Und wenn du es noch nicht auf deinem Rechner hast, dann folge diesen Anweisungen: GitHub - esp8266/Arduino: ESP8266 core for Arduino

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

Da kommt dann:
18
00
15
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

Der Sketch läuft zwar, aber ist nicht ideal, um zu erweitern.
Hier gilt im Prinzip das gleiche wie beim blockierungsfreien Einlesen von der seriellen.

Zeile komplett bis Zeilenende
Dann das Empfangene auswerten mit str-Funktion und tun, was man tun muss.
Dann nächste Zeile.

Ich dachte damit liest er bis zum Zeilenende ein?! :o

"String req = client.readStringUntil('\r');"

Im Prinzip schon, aber was ist, wenn auch technischen Gründen/Problemen das Zeilenende nicht kommt?

Stichwort: blockierungsfrei

Nu mach es nicht so spannend: Wie macht man es besser?

Muss den Thread raussuchen. War erst vor kurzem

Edit: Habs gefunden Link post #14 ist das Grundgerüst. Lies aber den ganzen Thread.

Aber da erzähle ich dir ja nix neues.