WiFi Kochbuch mit ESP8266

Das WiFi-Modul ESP8266 ermöglicht es mit dem Arduino auf einfache Weise mit einem Partner im WLAN oder im Internet zu kommunizieren. Die einfache Handhabung und nicht zuletzt der niedrige Preis machen das Modul sehr attraktiv. Man bekommt die einfachste Version für weniger als 5 Euro.

ESP8266_01

Obwohl das Modul relativ neu auf dem Markt ist, gibt es im Internet viele Anleitungen für die erste Kontaktaufnahme mit dem Modul. Unter der Überschrift „Erste Schritte“ gehen diese Anleitungen jedoch nicht soweit, ein komplettes Anwendungsbeispiel zu zeigen.

Ich möchte hier einen Sketch vorstellen, der zeigt, wie man mit diesem Modul den Arduino steuern kann.

Hier wird einfach die LED an Port 13 ein- und ausgeschaltet oder zum Blinken gebracht. Die Pulsdauer für das Blinken kann verändert werden. Die Steuerung erfolgt mit einer HTML-Eingabemaske, die der Arduino erzeugt und an den Client sendet.

ESP5266_03

Das Beispiel kann leicht für andere Anwendungen angepasst und erweitert werden. Ein- und Ausgaben in Form von Beschriftungen, Eingabefeldern und Radiobuttons zeigen beispielhaft wie es funktioniert. Der gewünschte Zustand der Led wird im Parameter LED mit den Werten Ein, Aus oder Blk zurückgegeben. Die Pulsdauer im Parameter PULS. Dies ist 4-stelliger Zahlenwert.

Für das Modul habe ich mir ein Schild gebaut.

ESP5266_02

Hier die Beschaltung :

ESP5266_04

Das Modul kann kurzzeitig bis zu 200 mA Strom benötigen. Deshalb habe ich die vom Arduino gelieferte Versorgungsspannung mit einem Elko gestützt. Für große Entfern- ungen kann das jedoch nicht ausreichend sein, sodass eine eigene, leistungsfähige 3,3V Stromversorgung notwendig ist..

Um das Signal vom 5 V Ausgang des Arduino an den 3,3 V Eingang des Moduls anzupassen, ist  in der TX-Leitung des Arduino ein Spannungsteiler. In umgekehrter Richtung ist keine Signalanpassung notwendig; der Arduino erkennt auch Signale mit 3,3 V Spannung.

Update 22.12.2014 : Ich nun habe den Sketch umgeschrieben, sodaß die  Text-Konstanten weitgehend im Flash-Memory gespeichert werden. Das führt zu einer deutlichen Verringerung des belegten SRAMs : Bisher 1755 Byte (85%) jetzt nur noch 623 Byte (30 %).

Update 04.01.2015 : Im Beitrag einige Ergänzungen und Klarstellungen eingebaut, die sich aus den Komentaren ergeben haben. Im  Beispielsketch fehlte die Deklaration einer Routine. Dank an Andreas und Manfred für die Hinweise.

Hier das Coding meines Sketches (04.01.2015) : Dieser Seketch wurde mit FirmwareVersion 0901 und 0922 getestet.

//--------------------------------------------------------------------------
// Wifi Modul ESP8266 Beispiel Programm
//--------------------------------------------------------------------------
// Autor : Hubert Baumgarten
// Datum : 04.01.2015
//--------------------------------------------------------------------------
// Basis war das Beispiel von Ray Wang  http://rayshobby.net/?p=9734
//--------------------------------------------------------------------------

#include <avr/pgmspace.h>

#define WIFI_DEBUG

#define WIFI_Serial Serial
#define Debug_Serial mySerial

#ifdef WIFI_DEBUG
#include <SoftwareSerial.h>
SoftwareSerial mySerial(10,11); // RX, TX
#endif

#define WIFI_ERROR_NONE 0
#define WIFI_ERROR 1

//---------------------------------------------------------------------------
// HTML
int HTML_Content_Length;
int HTML_Header_Length;
int HTML_Temp_Length;
byte HTML_Sende_Mode;
int HTML_Counter = 0;

#define HTML_SENDE_MODE_PREPARE 0
#define HTML_SENDE_MODE_SEND 1

//---------------------------------------------------------------------------
// WIFI
char WIFI_Net[30];
char WIFI_IP_Adress[20];
#define PORT 80
char WIFI_Host[24];
int WIFI_CWMODE;
#define CWMODE_STATION 1
#define CWMODE_ACCESSPOINT 2
int WIFI_Setup_Error = 0;

//---------------------------------------------------------------------------
// Receive-Buffer
#define RECV_BUFFER_SIZE 100
char RECV_Buffer[RECV_BUFFER_SIZE];

//---------------------------------------------------------------------------
// LED Handling
#define LEDMODE_AUS 0
#define LEDMODE_EIN 1
#define LEDMODE_BLINK 2
#define LEDPIN 13
int led_value = LOW;
int led_mode = LEDMODE_AUS;
unsigned long led_nextpuls = 0;
int led_pulsdauer = 500;

//-----------------------------------------------------------------------
// Routinen deklarieren
int WIFI_Setup();
void RECV_Buffer_Clear();
void Led_Handling();
void Set_Led(int p);
void HTML_Page(int WIFI_Cannel);
void HTML_Make_Header();
void HTML_Make_Content();
void HTML_Send(char * c);
void HTML_Send_Int(int z);
void HTML_Send_PROGMEM(const __FlashStringHelper* tx);

//--------------------------------------------------------------------------------------
void setup() {
  pinMode(LEDPIN, OUTPUT);

  WIFI_Serial.begin(115200);
  WIFI_Serial.setTimeout(5000);

#ifdef WIFI_DEBUG
  Debug_Serial.begin(9600);
#endif
  //----------------------------------
  // 3 sec warten
  delay (3000);

  Set_Led(HIGH);

  WIFI_Setup_Error = WIFI_Setup();

#ifdef WIFI_DEBUG
  if (WIFI_Setup_Error) {
    Debug_Serial.println(F("Error"));
  }
#endif

  if (WIFI_Setup_Error) led_mode = LEDMODE_BLINK;
  else Set_Led(LOW);

  WIFI_Serial.setTimeout(20);
  WIFI_Host[0] = 0;
  RECV_Buffer_Clear();
}
//--------------------------------------------------------------------------
void loop() {

  int WIFI_Cannel, WIFI_Packet_Length;
  int i;
  char *buffer_pointer;
  byte len;

  // request: +IPD,ch,len:GET /?LED=xxx&PULS=nnnn ... Host: nnn.nnn.nnn.nnn:nnnn 0x0D ...

  if (WIFI_Serial.findUntil("+IPD,", "\r")) {

    WIFI_Cannel = WIFI_Serial.parseInt();
    WIFI_Serial.findUntil(",", "\r");
    WIFI_Packet_Length = WIFI_Serial.parseInt();

    if (WIFI_Serial.findUntil("GET /", "\r")) {

      WIFI_Serial.readBytesUntil(13, RECV_Buffer, RECV_BUFFER_SIZE);

      if (WIFI_Packet_Length > 0) {
        buffer_pointer = RECV_Buffer;
        if (strncmp(buffer_pointer, "?LED=", 5) == 0) {
          buffer_pointer += 5;
          if (strncmp(buffer_pointer, "Ein", 3) == 0) {
            led_mode = LEDMODE_EIN;
          }
          if (strncmp(buffer_pointer, "Aus", 3) == 0) {
            led_mode = LEDMODE_AUS;
          }
          if (strncmp(buffer_pointer, "Blk", 3) == 0) {
            led_mode = LEDMODE_BLINK;
          }
          buffer_pointer += 3;
          if (strncmp(buffer_pointer, "&PULS=", 6) == 0) {
            buffer_pointer += 6;
            for (i = 0; i < 5; i++) {
              if (buffer_pointer[i] < '0' || buffer_pointer[i] > '9') buffer_pointer[i] = 0;
            }
            led_pulsdauer = atoi(buffer_pointer);
          }
        }
        WIFI_Host[0] = 0;
        if (WIFI_Serial.find("Host: ")) {
          len = WIFI_Serial.readBytesUntil(13, WIFI_Host, 23);
          WIFI_Host[len] = 0;
        }
        HTML_Page(WIFI_Cannel);
      }
    }
    RECV_Buffer_Clear();
  }
  Led_Handling();
}



//----------------------------------------------------------------------
int WIFI_Setup() {
  byte len;

  RECV_Buffer_Clear();

  //-----------------------------------------------------------
  // start server

#ifdef WIFI_DEBUG
  Debug_Serial.println(F("AT+CIPMUX"));
#endif

  WIFI_Serial.println(F("AT+CIPMUX=1"));
  delay(10);
  // normale Antwort :
  //   "AT+CIPMUX=1" 0xD 0xD 0xA 0xD 0xA "OK" 0xD 0xA

  if (!WIFI_Serial.find("OK")) {
    return WIFI_ERROR;
  }
  RECV_Buffer_Clear();

  //-----------------------------------------------------------
  // TCP service aktivieren

#ifdef WIFI_DEBUG
  Debug_Serial.println(F("AT+CIPSERVER"));
#endif
  WIFI_Serial.print(F("AT+CIPSERVER=1,"));
  WIFI_Serial.println(PORT);
  delay(10);

  // normale Antwort :
  //   "AT+CIPSERVER=1,8080" 0xD 0xD 0xA 0xD 0xA "OK" 0xD 0xA

  if (!WIFI_Serial.find("OK")) {
    return WIFI_ERROR;
  }

  RECV_Buffer_Clear();

  //-------------------------------------------------------------------------
  // Timeout für automatisches Trennen der Verbindung setzen

#ifdef WIFI_DEBUG
  Debug_Serial.println(F("AT+CIPSTO"));
#endif

  WIFI_Serial.println(F("AT+CIPSTO=0"));
  delay(10);
  if (!WIFI_Serial.find("OK")) {
    return WIFI_ERROR;
  }

  //---------------------------------------------------------------------------
  // WiFi Modus ermitteln

  RECV_Buffer_Clear();
  WIFI_Net[0] = 0;

#ifdef WIFI_DEBUG
  Debug_Serial.println(F("AT+CWMODE?"));
#endif

  WIFI_Serial.println(F("AT+CWMODE?"));
  delay(10);
  // Normale Antwort AT+CWMODE? 0x0D 0x0D 0x0A+CWMODE:1 0x0D 0x0A 0x0D 0x0A OK 0x0D 0x0A

  WIFI_CWMODE = 0;
  if (WIFI_Serial.find("AT+CWMODE?\r\r\n+CWMODE:")) {
    WIFI_CWMODE = WIFI_Serial.parseInt();
  }

#ifdef WIFI_DEBUG
  Debug_Serial.print(F("CWMode:"));
  Debug_Serial.println(WIFI_CWMODE);
#endif

  if (WIFI_CWMODE == 0) {
    return WIFI_ERROR;
  }

  //---------------------------------------------------
  // Ich bin Station. In welchem Netz bin ich ?

  if (WIFI_CWMODE == CWMODE_STATION) {

#ifdef WIFI_DEBUG
    Debug_Serial.println(F("AT+CWJAP?"));
#endif

    WIFI_Serial.println(F("AT+CWJAP?"));
    delay(10);
    // Normale Antwort AT+CWJAP? 0x0D 0x0D 0x0A +CWJAP:"<SSID>" 0x0D 0x0A 0x0D 0x0A OK 0x0D 0x0A

    len = 0;
    WIFI_Net[0] = 0;
    if (WIFI_Serial.find("AT+CWJAP?\r\r\n+CWJAP:\"")) {
      len = WIFI_Serial.readBytesUntil('\"', WIFI_Net, 20);
      WIFI_Net[len] = 0;
    }

    if (len > 0) {
#ifdef WIFI_DEBUG
      Debug_Serial.println(F("Netzwerk:"));
      Debug_Serial.println(WIFI_Net);
#endif
    }
    else {
      return WIFI_ERROR;
    }
  }
  //------------------------------------------
  // Ich bin Accesspoint, wie heisse ich ?
  if (WIFI_CWMODE == CWMODE_ACCESSPOINT) {

#ifdef WIFI_DEBUG
    Debug_Serial.println(F("AT+CWSAP?"));
#endif

    WIFI_Serial.println(F("AT+CWSAP?"));
    delay(10);
    // Normale Antwort AT+CWSAP? 0x0D 0x0D 0x0A +CWSAP:"MyESP",
    //                 "12345678",8,3 0x0D 0x0A 0x0D 0x0A OK 0x0D 0x0A
    len = 0;
    WIFI_Net[0] = 0;
    if (WIFI_Serial.find("AT+CWSAP?\r\r\n+CWSAP:\"")) {
      len = WIFI_Serial.readBytesUntil('\"', WIFI_Net, 20);
      WIFI_Net[len] = 0;
    }

    if (len > 0) {
#ifdef WIFI_DEBUG
      Debug_Serial.println(F("Netzwerk:"));
      Debug_Serial.println(WIFI_Net);
#endif
    }
    else {
      return WIFI_ERROR;
    }
  }

  //-----------------------------------------------------------
  // Get IP Adress

#ifdef WIFI_DEBUG
  Debug_Serial.println(F("AT+CIFSR"));
#endif

  WIFI_Serial.println(F("AT+CIFSR"));
  delay(1000);

  // Normale Antwort z.B.
  // AT+CIFSR 0xD 0xD 0xA 192.168.178.26 0xD 0xA

  len = 0;
  WIFI_IP_Adress[0] = 0;
  if (WIFI_Serial.find("AT+CIFSR\r\r\n")) {
    len = WIFI_Serial.readBytesUntil('\r', WIFI_IP_Adress, 20);
    WIFI_IP_Adress[len] = 0;
  }
#ifdef WIFI_DEBUG
  if (len > 0) {
    Debug_Serial.println(F("IP"));
    Debug_Serial.println(WIFI_IP_Adress);
  }
#endif
  if (len == 0) {
    return WIFI_ERROR;
  }

#ifdef WIFI_DEBUG
  Debug_Serial.println(F("Setup okay"));
#endif

  return WIFI_ERROR_NONE;
}

//----------------------------------------------------------------------

void HTML_Page(int WIFI_Cannel) {

  HTML_Counter++;

#ifdef WIFI_DEBUG
  Debug_Serial.print(F("Zaehler: "));
  Debug_Serial.println(HTML_Counter);
#endif

  HTML_Sende_Mode = HTML_SENDE_MODE_PREPARE;

  HTML_Temp_Length = 0;
  HTML_Make_Content();
  HTML_Content_Length = HTML_Temp_Length;

  HTML_Temp_Length = 0;
  HTML_Make_Header();
  HTML_Header_Length = HTML_Temp_Length;

  WIFI_Serial.print(F("AT+CIPSEND="));
  WIFI_Serial.print(WIFI_Cannel);
  WIFI_Serial.print(F(","));
  WIFI_Serial.println(HTML_Header_Length + HTML_Content_Length);

  delay(20);

  RECV_Buffer_Clear();

  HTML_Sende_Mode = HTML_SENDE_MODE_SEND;
  HTML_Make_Header();
  HTML_Make_Content();

  delay(10);
}

//---------------------------------------------------------------------------
void HTML_Make_Header() {

  HTML_Send_PROGMEM(F("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: close\r\n"));
  HTML_Send_PROGMEM(F("Content-Length:"));
  HTML_Send_Int(HTML_Content_Length);
  HTML_Send_PROGMEM(F("\r\n\r\n"));
}

//---------------------------------------------------------------------------
void HTML_Make_Content() {

  HTML_Send_PROGMEM(F("<HTML><HEAD> <title>Arduino Steuerung</title></HEAD>\n"));

  HTML_Send_PROGMEM(F("<BODY bgcolor=\"#ADCEDE\" text=\"#000000\">"));

  HTML_Send_PROGMEM(F("<FONT size=\"6\" FACE=\"Verdana\">Arduino Steuerung<BR/></FONT>"));

  HTML_Send_PROGMEM(F("<FONT size=\"3\" FACE=\"Verdana\">\n<BR/>Hubbie's Arduino Uno<BR/>"));

  HTML_Send_PROGMEM(F("Led : "));
  switch (led_mode)  {
    case LEDMODE_AUS:
      HTML_Send_PROGMEM(F("aus"));
      break;
    case LEDMODE_EIN:
      HTML_Send_PROGMEM(F("ein"));
      break;
    case LEDMODE_BLINK:
      HTML_Send_PROGMEM(F("blinkt"));
      break;
  }
  HTML_Send_PROGMEM(F("<BR/>\n"));

  //--------------------------------------
  // Aufrufzaehler
  HTML_Send_PROGMEM(F("Aufrufz&auml;hler = "));
  HTML_Send_Int(HTML_Counter);

  HTML_Send_PROGMEM(F("<BR/></font>"));

  HTML_Send_PROGMEM(F("<FORM ACTION=\"http://"));
  HTML_Send(WIFI_Host);
  HTML_Send_PROGMEM(F("\">"));

  HTML_Send_PROGMEM(F("<P><FONT size=\"3\" FACE=\"Verdana\">Led schalten :<BR/>"));

  if (led_mode == LEDMODE_EIN)  {
    HTML_Send_PROGMEM(F("<INPUT TYPE=\"RADIO\" NAME=\"LED\" VALUE=\"Ein\"> Einschalten<BR/>"));
    HTML_Send_PROGMEM(F("<INPUT TYPE=\"RADIO\" NAME=\"LED\" VALUE=\"Aus\" CHECKED> Ausschalten<BR/>"));
  }
  else
  {
    HTML_Send_PROGMEM(F("<INPUT TYPE=\"RADIO\" NAME=\"LED\" VALUE=\"Ein\" CHECKED> Einschalten<BR/>"));
    HTML_Send_PROGMEM(F("<INPUT TYPE=\"RADIO\" NAME=\"LED\" VALUE=\"Aus\"> Ausschalten<BR/>"));
  }

  HTML_Send_PROGMEM(F("<INPUT TYPE=\"RADIO\" NAME=\"LED\" VALUE=\"Blk\"> Blinken"));

  HTML_Send_PROGMEM(F("&emsp;&emsp;&emsp;&emsp;&emsp;Plusdauer:<INPUT NAME=\"PULS\" TYPE=\"TEXT\" size=\"4\" MAXLENGTH=\"4\" VALUE=\""));
  HTML_Send_Int(led_pulsdauer);
  HTML_Send_PROGMEM(F("\"> mSec<BR/>"));
  HTML_Send_PROGMEM(F("<BR/>"));

  //--------------------------------------
  // Absende-Knopf

  HTML_Send_PROGMEM(F("<INPUT TYPE=\"SUBMIT\" VALUE=\" Absenden \">"));
  HTML_Send_PROGMEM(F("</FONT></P>"));
  HTML_Send_PROGMEM(F("</BODY></HTML>"));
}

//---------------------------------------------------------------------------
void HTML_Send_Int(int p_int) {
  char tmp_text[8];
  itoa(p_int, tmp_text, 10);
  HTML_Send(tmp_text);
}

//---------------------------------------------------------------------------
void HTML_Send(char * p_text) {
  HTML_Temp_Length += strlen(p_text);
  if (HTML_Sende_Mode == HTML_SENDE_MODE_SEND) {
    WIFI_Serial.print(p_text);
  }
}

//---------------------------------------------------------------------------
void HTML_Send_PROGMEM(const __FlashStringHelper* p_text) {

  HTML_Temp_Length += strlen_P((const char*)p_text);
  if (HTML_Sende_Mode == HTML_SENDE_MODE_SEND) {
    WIFI_Serial.print(p_text);
  }
}


//------------------------------------------------------------
void RECV_Buffer_Clear() {
  for (int i = 0; i < RECV_BUFFER_SIZE; i++) RECV_Buffer[i] = 0;
  while (WIFI_Serial.available())WIFI_Serial.read();
}

//--------------------------------------------------------------------
void Led_Handling() {

  if (led_mode == LEDMODE_AUS && led_value != LOW) Set_Led(LOW);
  if (led_mode == LEDMODE_EIN && led_value != HIGH) Set_Led(HIGH);
  if (led_mode == LEDMODE_BLINK && millis() > led_nextpuls) {
    led_nextpuls = millis() + (unsigned long)led_pulsdauer;
    if (led_value == LOW) Set_Led(HIGH);
    else Set_Led(LOW);
  }
}

//--------------------------------------------------------------------
void Set_Led(int p) {
  led_value = p;
  digitalWrite(LEDPIN, led_value);
}

Die Sketche zum download:

Neuere FirmwareVersionen ermöglichen die Einstellung der Baudrate für die serielle Kommunikation. Dies führt zu einer Verlangsamung des Datenverkehrs, was wiederum zu Komplikationen führen kann. Ich empfehle daher, die Einstellung 115200 Baud zu belassen.

In meinem Sketch habe ich viele Routinen generell anders aufgebaut, als in den vielen Beispielen im Internet:

  •  Auslesen der empfangenen Daten
    Der Arduino hat einen Puffer von nur 64 Zeichen. Eine Nachricht vom Client kann jedoch über 400 Zeichen lang sein, weil viele Angaben zum verwendeten Internetbrowser, zum Betriebssystem, zum Gerätetyp usw. enthalten sind. Also muß man immer versuchen, die Daten schneller auszulesen als Daten empfangen werden. Dafür eignen sich treffsicher formulierte Befehle wie Find und ReadUntil.
  • Aufbau der Sendenachricht
    Das Protokoll sieht vor, dass am Anfang einer Nachricht die Gesamtlänge der Nachricht angegeben wird. Deshalb wird in vielen Beispielen zunächst die gesamte Nachricht zusammengebaut. Häufig wird sogar mit einer Stringvariablen gearbeitet. Das kostet jedoch sehr viel Arbeitsspeicher. Ich erzeuge eine relativ große HTML-Nachricht und baue deshalb die Nachricht Stück für Stück auf. Dabei nutze ich die Möglichkeit, die Texte im Flash-Memory zu speichern. Ich mache 2 Durchläufe. Im ersten Durchlauf wird nur die Länge der Nachricht ermittelt; erst im 2. Durchlauf wird die Nachricht gesendet.
  • Empfänger IP im Absendebutton
    Mit dem Absende-Button wird aus der HTMLSeite heraus an das ESP-Modul eine neue Nachricht erzeugt. Abhängig von der Arbeitsweise des Moduls ist die IP des Empfängers mal die lokale WLAN-IP, die globale IP des Routers oder die Server-IP des Moduls. Mein Sketch liest die richtige IP aus der eingehenden Nachricht. Der ausgewertete Parameter heißt HOST .

Das ESP8266-Modul hat 2 verschiedene Betriebsarten. Die Betriebart wird über das AT-Kommando CWMODE eingestellt.

  • Als Client im WLAN (Station)
    Hier müssen mit dem AT-Kommando CWJAP die Zugangsdaten (SSID und Passwort) eingestellt werden.
  • Als Router im selbst erzeugten WLAN (Accesspoint)
    Hier müssen mit dem AT-Kommando CWSAP die WLAN-Parameter (SSID, Passwort, WLAN-Kanal und Art der Verschlüsselung) eingestellt werden. Fabrikneue Module sind auf diese Betriebsart eingestellt, mit offenen WLAN-Netz. In diesem Arbeitsmodus hat das Modul die feste IP-Adresse 192.168.4.1. Es können bis zu 5 Clients gleichzeitig angemeldet sein. Die Clients können jedoch nicht untereinander kommunizieren.

Die o.g. Einstellungen müssen nur einmal gemacht werden. Sie bleiben nach dem Ausschalten erhalten. Mein Beispiel-Sketch setzt diese Einstellungen nicht. Das hat den Vorzug, dass er universeller einsetzbar ist. Im oben angegebenen ZIP-File sind Sketche enthalten, die diese Parameter setzen. In diesen Sktechen müssen die eigenen Parameterwerte eingetragen werden. Sie müssen nur einmalig ausgeführt werden.

Im Arbeitsmodus Client im WLAN bezieht das Modul vom Router die lokale IP-Adresse. Das kann bei jedem Programmstart eine andere sein. Es empfiehlt sich daher im Router (Speedport oder Fritzbox …) eine Einstellung vorzunehmen, die dafür sorgt, dass für das ESP-Modul immer die gleiche IP-Adresse vergeben wird. Diese Adresse muß man mit dem Internetbrowser aufrufen. Will man aus dem Internet auf das Modul zugreifen, muß man in seinem Router eine Weiterleitung Port an sein ESP-Mudul eintragen. Hat man nur einen Anwerndungsfall kann man Port 80 verwenden. Dies ist der Standard für HTTP und braucht dann nicht angegeben zu werden.
Um über das Internet zugreifen zu können, muß man die globale IP seines Routers kennen. Diese wechselt jedoch täglich. Ein Methode diese auch von ausserhalb zu erfahren ist, sich vom Router eine automatische Mail mit der aktuellen IP schicken zu lassen. Diese Mail muß man von ausserhalb lesen können. Viele Router bieten diese Möglichkeit an.

Abschliessend hier meine Beschreibung der wichtigsten AT-Kommandos. Die angegebenen Antowrten wurden mit der FirmwareVersion 0901 ermittelt. Mit anderen FirmwareVersionen können die Antworten anweichend sein.

AT Hallo bist Du da ?

Aufruf : AT
Antwort : AT OK

  • AT+RST    Reset

Aufruf :              AT+RST
Antwort :           AT+RST <cr> <crlf> <crlf> OK <crlf> <crlf> <space> ets <space> Jan <space> <space> 8 <space> 2013,rst <space> cause:4, <space> boot <space> mode:(3,5) <crlf> <crlf>wdt <space> reset <crlf>load <space> 0x40100000, <space> len <space> 244 <space> o1 <space> tl2 <lf> k00h0a2o <space> <cr> o <space> 3f0,e8 <space> ackmxldxf809o4 <cr> a <space> hu0d <lf> u0b <lf> rd <cr>

Anmerkung     Prüfen die Antwort auf “reset”. Der restliche Inhalt ist unerklärbar.

  • AT+CWMODE   WiFi Modus

Bedeutung:  

1 = Station (Server im vorhandenen WLAN),
2 = Accesspoint, (eigenes WLAN-Netzwerk),
3 = beides

Aktuellen Wert Abfragen :
Aufruf :              AT+CWMODE?
Antwort :           AT+CWMODE? <cr> <crlf>+CWMODE:2 <crlf> <crlf> OK <crlf>

Erlaubte Werte abfragen :
Aufruf :              AT+CWMODE=?
Antwort :           AT+CWMODE=? <cr> <crlf> +CWMODE:(1-3) <crlf> <crlf> OK <crlf>

Wert setzen :
Aufruf :              AT+CWMODE=1

Wenn der Modus bisher anders war :
Antwort :           AT+CWMODE=1 <cr> <crlf> <crlf> OK <crlf>

sonst :
Antwort :           AT+CWMODE=1 <cr> <crlf>no <space> change <crlf>

Der geänderte Wert wird er nach einem Reset wirksam; also anschiessend AT+RST schicken.

  • AT+CWLAP       Verfügbare Netze anzeigen

Aufruf :         AT+CWLAP
Antwort :      AT+CWLAP <cr> <crlf> +CWLAP:(0,““,0) <crlf> +CWLAP:(3,“Netzwerk1″,-66) <crlf> +CWLAP:(4,“Netzwerk2″,-44) <crlf> OK <crlf>

Jedes Netzwerk wird mit Art der Verschlüsselung, SSID und Signalstärke (in dB) ausgegeben,

  • AT+CWJAP       WLAN-Router setzen

Aktuellen Wert Abfragen :
Aufruf :         AT+CWJAP?
Antwort :      AT+CWJAP? <cr> <crlf> +CWJAP:“<SSID>“ <crlf> <crlf> OK <crlf>

Die <SSID> ist leer, wenn keine Verbindung besteht.

Wert setzen:
Aufruf :         AT+CWJAP=“<SSID>“,“<Passwort>“
Antwort :      AT+CWJAP=“<SSID>”,“<Passwort>“ <cr> <crlf> <crlf> OK <crlf>

Diese Einstellung wird erst nach dem nächsten PowerOn wirksam, sie bleibt auch nach dem Ausschalten erhalten.

  • AT+CIPSTATUS        Status abfragen

 Aufruf :         AT+CISPTATUS

Wenn nicht verbunden (Status 1)
Antwort :      AT+CIPSTATUS <cr> <crlf> STATUS:1 <crlf> <crlf> OK <crlf>

Wenn verbunden (Status 3) z.B.
Antwort :      AT+CIPSTATUS <cr> <crlf> STATUS:3 <crlf> +CIPSTATUS:0,“TCP“,“192.168.178.21″,50324,1 <crlf> <crlf> OK <crlf>

Es fehlt eine vollständige Liste aller Status und deren Bedeutung.

  • AT+CIFSR         Aktuelle IP-Adresse abfragen

 Aufruf :         AT+CIFSR

Wenn nicht verbunden
Antwort :      AT+CIFSR <cr> <crlf> <crlf> ERROR <crlf>

Wenn verbunden.
Antwort :      AT+CIFSR <cr> <crlf> 192.168.178.29 <crlf>

  • AT+CWQAP      Verbindung trennen

Aufruf :        AT+CWQAP
Antwort :      AT+CWQAP <cr> <crlf> <crlf> OK <crlf>

  • AT+CIPMUX      Einzel/Multi – Verbindungsmodus-Modus

Bedeutung: 0 = Einzel-Verbindung 1 = Multi-Verbindung

Wert abfragen
Aufruf :         AT+CIPMUX?
Antwort :      AT+CIPMUX? <cr> <crlf> +CIPMUX:0 <crlf> <crlf> OK <crlf>

Wert setzen
Aufruf :         AT+CIPMUX=1
Antwort :      AT+CIPMUX=1 <cr> <crlf> <crlf> OK <crlf>

  • AT+CWSAP       Accesspoint-Parameter setzen

Hier wird die eigene SSID, das Passwort ,der WLAN-Kanal und die Sicherungsart fgestgelegt. Die Verbindung läuft stabiler, wenn der gewählte WLAN-Kanal frei ist, also kein weiteres Netzwerk damit arbeitet.

Die Sicherungsart kann folgende Werte annehmen :

0 = offen, ohne Passwort
1 = WEB
2 = WPA_PSK
3 = WPA2_PSK
4 = WPA_WPA2_PSK

Wert abfragen
Aufruf :         AT+CWSAP?
Antwort :      AT+CWSAP? <cr> <crlf> +CWSAP:“Hubbie_ESP01″,“12345678″,8,3 <crlf> <crlf> OK <crlf>

Wert setzen
Aufruf :         AT+CWSAP=“ESP01″,“12345678″,8,3
Antwort :      AT+CWSAP=“ESP01″,“12345678″,8,3 <cr> <crlf> <crlf> OK <crlf>

Das ESP-Modul ist anschliessend im angegebenen Netz, unter der IP-Adresse 192.168.4.1 erreichbar.

Das Passwort muß mindestens 8 Stellen lang sein und muß auch bei Sicherungsart 0 (offener Zugang; ohne Passwort eingabe) angegeben werden.

Diese Einstellung wird erst nach dem nächsten PowerOn wirksam, sie bleibt auch nach dem Ausschalten erhalten.

 

113 Gedanken zu „WiFi Kochbuch mit ESP8266

  1. Schön beschrieben, aber wie bei den meisten anderen auch: Die Download-Beispiele funktionieren nicht — wie fast immer.
    Echt schade, ich dachte, diesmal würde ich mein ESP vernünftig zum Laufen bekommen…
    ———-Wifi Modul ESP8266 Parameter als Station setzen:
    AT+CWMODE=1
    AT+RST
    Error
    ==> und dann gar nix mehr

    ————// Wifi Modul ESP8266 Parameter als Accrsspoint setzen:
    AT+CWMODE=2
    AT+RST
    AT+CWSAP
    Setup okay
    ===> IPHONE mit AP verbunden, aber was dann? Ich bin gleichen Netzwerk, aber das war es dann auch??

    —————-// Wifi Modul ESP8266 Beispiel Programm:
    schon beim kompilieren kommt bei „HTML_Page(WIFI_Cannel);“ :
    =>SP8266_Uno01_ProgMem.ino: In function ‚void loop()‘:
    ESP8266_Uno01_ProgMem:152: error: ‚HTML_Page‘ was not declared in this scope

    Bin außer bei diesem ESP-Modul echt kein Anfänger.
    Das alles auf einem IMac OS X 10.6.8 mit Arduino 1.0.5

    Schönen Gruß aus dem nahen Lübbecke

    Andreas

    • Hallo Andreas,
      .
      ich habe jetzt festgestellt, dass die Antworten des ESP-Moduls abhängig von der Firmware-Version, unterschiedlich sind.
      .
      Ursprünglich habe ich mit der Version 0901 gearbeitet. Jetzt habe ich das Update auf 0922 aufgespielt.
      .
      Ich weis nicht welche Firmware-Version Du hast.
      .
      Um die Probleme mit „ESP8266 Parameter als Station setzen“ und „Wifi Modul ESP8266 Parameter als Accesspoint setzen“ zu beseitigen, ersetze die Prüfung nach AT+RST auf „Ready“ oder nimm sie ganz raus.
      .
      Im Beispiel-Programm fehlt die Deklaration der Routine HTML_Page(int WIFI_Cannel). Meine
      Arduino-Version 1.5.8 hat den Sketch trotzdem klaglos kompiliert.
      .
      Abhilfe : Bitte füge vor „void setup() {“ folgendes ein : „void HTML_Page(int WIFI_Cannel);“
      .
      Das Beispiel-Programm läuft mit beiden Firmware-Versionen 0901 und 0922 problemlos.
      .
      Ein Feedback wäre nett.
      ,
      Viele Grüße
      .
      Hubert

      • Hallo Hubert, erst einmal vielen Dank für Deine schnelle Antwort.
        Ich habe heute wieder lange davor gesessen und folgendes erreicht:
        „Firmware ist:AT+GMR
        0018000902-AI03
        OK“
        Ich werde mir wohl die Mühe machen müssen, auf 0922 upzudaten…
        Ich habe im Auslieferungszustand übrigens 9600 baud.

        Zum Webserver: ich bekomme eine Verbindung, finde das Modul im AP (TP-extender) als verbunden unter 192.168.0.124 mit MAC-Adresse, bin natürlich im gleichen Netzwerk, kann aber im Browser unter 192.168.0.124:80 keine Verbindung herstellen (Firefox kann keine Verbindung zu dem Server unter 192.168.0.124 aufbauen.)

        ??? Fällt Dir noch ein Tip ein?

        BTW: kann ich unter Arduino-Version 1.5.8 auch ganz normal einen Mega oder UNO laufen lassen? Ich dachte, die Version wäre nur für den DUE??

        Lieben Gruß
        Andreas

        • Sorry, das ist die Debug-Ausgabe zu meinem Post

          AT+CIPMUX
          AT+CIPSERVER
          AT+CIPSTO
          AT+CWMODE?
          CWMode:1
          AT+CWJAP?
          Netzwerk:
          TP-extender
          AT+CIFSR
          IP
          192.168.0.124
          Setup okay
          Zaehler: 1

          • Hallo Andreas,
            .
            Deine Debug-Ausgabe ist völlig in Ordnung. Die Ausgabe „Zaehler : 1“ bedeutet : Dein WEB-Client hat eine Anforderung geschickt, diese wurde erkannt und beantwortet.
            .
            Vermutlich kam die Antwort nicht schnell genug beim WEB-Client an. Damit die Antwort schneller an den WEB-Client geschickt wird, arbeite mit der Baud-Rate 115200. Mit 9600 Baud funktioniert es bei mir auch nicht.
            .
            Achte auch auf eine ausreichende 3,3 V Stromversorgung.
            .
            Ein Upgrade auf die 0922-Firmware halte ich nicht für zwingend erforderlich.
            .
            Meine Arduino-Version 1.5.8 arbeitet mit allen bekannten Boads, ohne Einschränkung.
            .
            Viel Erfolg
            .
            Hubert

  2. Meine Bestellung aus China ist leider noch nicht angekommen,
    bin schon gespannt das ganze auszuprobieren.

    Ich werde dann mal berichten.

  3. Zunächst ein GROSSES Lob an Hubert. Die Beschreibung und die AT Befehlsliste ist 1A.
    Ich versuche gerade eine 7er Version an einem Leonardo zum Laufen zu bringen.
    Sehr gute Idee von Hubert für die beiden Seriellen IOs eigene Namen vorzusehen. Dann einfach das mySerial beim Debug_Serial durch Serial1 ersetzen, den Softserial include plus mySerial entfernen.
    Bin so weit, dass das Teil als AP sendet. Interaktion auf +IDP läuft bei mir (leider) noch nicht, aber ich arbeite daran. Vielleicht liegt es an den 9600baud?

    Hier ein paar Hinweis, die vielleicht auch andere ESP8266-07 Nutzer helfen könnten:
    a) 3.3V Stromversorgung: unbedingt einen eigenen 3.3V Regler mit ausreichend großem Pufferelko (>470mü) vorsehen. Die 3.3 aus dem FTDI sind zu schwach.
    b) CH_PD auf +3.3V
    c) GPIO15 auf GND ! Ohne geht’s bei mir jedenfalls nicht
    d) mein ESP ist auf 9600 baud eingestellt, daher diese im Sketch entsprechen einstellen.
    e) ganz wichtig: das Passwort bei AT+CWSAP muss > 8 Zeichen betragen auch wenn Sicherungsart 0 gewählt wird.

    Gruß aus dem schönen Elmshorn
    Manfred

  4. Pingback: Review Dorkbot Januar 2015 | Dingfabrik Köln e.V. | Erzbergerplatz 9 | 50733 Köln

    • Hallo Olaf,
      .
      ich benutze den Debug-Monitor, den ich im vorgerigen Beitrag vorgestellt habe, siehe :
      .
      http://arduino-hannover.de/2014/11/29/debug-monitor-mit-nokia-lcd-display-5110/
      .
      Du kannst natürlich auch einen 2. Arduino verwenden und (über Kreuz) die SoftSerial Anschlüsse verbinden.
      .
      Super einfach geht es mit einem Mega. Da schliesst Du das ESP-Modul an Serial1 an und änderst nur :
      .
      #define WIFI_Serial Serial1
      #define Debug_Serial Serial
      //
      // #ifdef WIFI_DEBUG
      // #include
      // SoftwareSerial mySerial(10,11); // RX, TX
      // #endif
      .
      Viel Erfolg
      .
      Hubert Je suis Charlie

      • Hallo Hubert,
        vielen Dank für Deine Antwort, in Deiner Beschreibung zum Debug-Monitor schreibst Du man könne jeden Port als SoftSerial Anschluß definieren, wow. Oder meinst Du oben die Ports MISO und MOSI?

        Kannst Du mir einen Link schicken zur Lösungsvariante 2 Arduino über die SoftSerial-Anschlüsse verbinden, bes. zur Handhabung des Bootloaders?

        Viele liebe Grüße

        Olaf
        Je suis Charlie aussi

      • P.S. Dann könnte man doch aber auch das ESP mit dem SoftSerial Anschluß verbinden, oder? Fehlt da die Performance oder die Interruptfähigkeit?

        • Hallo Olaf,
          .
          mein Debug-Monitor ist ein Sonderfall, weil der Arduino nur Daten an den Debug-Monitor sendet, von dort aber nie Daten gesendet werden. Im Arduino kann jeder Port (als TX) genommen werden. Der RX (funktioniert nur mit Interuptfähigkeit des Port) muß zwar zugeordnet werden, wird aber nicht benutzt.
          .
          Die SoftwareSerialport-Library kann für das ESP-Modul nicht genutzt werden, es fehlt, wie Du vermutet hast, an der Performance. Die Library schafft die Baudrate 115200 nicht. Sie kann zwar eingestellt werden, funktioniert aber leider nicht.
          .
          Viele Grüße
          .
          Hubert Je suis Charlie

          • Hallo Hubert,
            vielen Dank, der Debug Monitor gefällt mir, bevor ich mit dem ESP weitermache werde ich erst mal das nachbauen 🙂 Super Sache!
            LG
            Olaf

  5. Hallo,

    mit der Firmwareversion 00200.9.5(b1) geht es wieder nicht.
    bis zum Setup okay habe ich schon alles korrigert.
    Dann werden die Daten aufbereitet, aber gehen nicht raus.

    mfg
    Ulli

      • Hmm, kaum ist eine Testausgabe hinter den …serial.find(„get \“……
        geht es (meistens).
        Ich glaube das ganze Timing muss ich mir mal genauer ansehen.
        Oh Moment , mit der 00200.9.5(b1) habe ich das gar nicht getestet.
        Ich hatte jetzt diese Firmware mit dem NTP-Client die auch erst nicht wollte.
        Heute abend checke ich mit der Testausgabe die 00200.9.5 noch mal.
        Nach dem find(„Get …. sind auch noch Kiloweise daten zum Arduino
        unterwegs, eventuell läuft da was über (or so).

        Ulli

    • Hallo Reinhold,

      das F(„…“) ist ein Makro das bewirkt, dass der String im Programmcode gespeichert wird und bei der Ausführung aus dem Programmcode ausgelesen wird. Paarig muß die aufgerufenen Routine den String mit const __FlashStringHelper* p_text übernehmen.

      Hubert

  6. Hallo,

    ich bin begeistert von der Geschwindigkeit der Übertragung des HTML-Codes auf den Browser. Bei allen anderen Programmen mit Arduino und ESP8255 dauerte der Aufbau einer komplexeren Seite über 30s. Mit Ihrem Code läuft dies innerhalb von Sekunden. Großes Lob.

    Ich möchte gerne einen Motor (Ausgang) des Arduino über nur ein Button auf dem Browser in „Todmannschaltung“ ansteuern.
    (Button drücken= Motor läuft, Button Loslassen=Motor stoppt)

    Der Code soll komplett vom Arduino auf den Browser übertragen werden, d.h. es soll kein Programm oder keine App auf dem Rechner oder dem Tablet installiert werden müssen.
    Kann mir jemand eine Anregung geben, wie man das realisieren kann?

    Mit freundlichen Grüßen

    Turtle

        • Hallo Hubert,

          ich habe eine Lösung für die „Todmann-Schaltung“ gefunden. Dazu habe ich Button erstellt, die mit
          HTML_Send_PROGMEM(F());

          So habe ich 4 Buttons erstellt, also mit M1-M4.

          Die entsprechenden Funktionen habe ich in „Java Script“ definiert.

          Das Programm läuft auch auf dem Client. Mann kann den Button drücken, die LED leuchtet und beim Loslassen wird die LED auch wieder ausgeschaltet.

          Leider funktioniert es nur ein paar mal (5-15 Mal) dann geht die Verbindung verloren und der Browser meldet keine Verbindung. Die Wlan Verbindung steht aber noch. Drücke ich dann RESET am Arduino kann ich nach eine Wartezeit von ca. 15s die Seite des Web Servers auch wieder aufrufen und die Buttons bedienen.

          Ich hatte das selbe Problem auch bei Deinem Ursprungsprojekt. Kann es daran liegen, dass man die Buttons zu schnell nacheinander drückt, bzw. bei mir zu schnell nacheinander drückt und wieder loslässt?

          Hast Du da eine Idee wie man das lösen kann?

          Mit freundlichen Grüßen

          Turtle

          • Hallo Turtle,
            .
            die Erfahrung hat gezeigt, dass der ESP stabiler läuft, wenn man den Reset-Eingang auf +3.3V legt.
            .
            Ich hoffe das hilft.
            .
            Hubert

  7. Vielen Dank für die tolle Anleitung!
    Der Arduino Due hat vier serielle Schnittstellen, und läuft mit 3.3V, deshalb wollte ich diesen verwenden. Das ganze mit Arduino IDE 1.6.4

    Zu Beginn hatte ich wenig Glück: Mein ESP8266 war auf 9600 Baud eingestellt, und man konnte dies nicht ändern. Mit 9600 Baud hat gar nichts funktioniert. Der Arduino ist beim ersten „Wifi_Serial.find“ hängengeblieben, obwohl ja ein Timeout ausdrücklich eingestellt wurden ist.

    Nach vielen Krämpfen konnte ich schliesslich die Firmware upgraden (AT 0.21.0.0, SDK 0.9.5), und den Chip mit 115200 Baud betreiben.

    Nun kam der Request an, aber die Antwort blieb hängen. Ich habe die Timeouts etwas erhöht nach dem Schreiben der Headerlänge, und dann hat es geklappt.

    Einzig das HTML scheint meinem Browser nicht so zu behagen: Der „Absenden“ Knopf wird bei Safari gar nie angezeigt, und bei Chrome nur die ersten 2-3 Mal.

    • Offenbar ist nicht das HTML ein Problem, sondern dass ab und zu ein Zeichen verschluckt wird. Z.B. sieht eine Antwortseite so aus:
      Ausschalten…

      Es fehlt also ein „Y“, so dass kein Radio-Button angezeigt wird an dieser Stelle.

  8. Danke für Ihre Artikel. Sie haben sehr einfach und verständlich AT befehle beschrieben. Ich habe aber Arduino für ESP8266 entdeckt und Programm direkt für ESP8266 Controller in Arduino DIE geschrieben. Da braucht man kein zusätzlicher Arduino-Board. Hier sind meine ersten Sketche http://esp8266-server.de/

  9. ich bin warscheinlich zu blöd aber ich habe das esp angeschlossen direkt an eine rs232 3.3 v an eine versorgungsspannung 3.3v hyperterminal win xp aber ich erhalte gar gein lebenszeichen weder mit 9k6 noch mit 115k2. was leuft da falsch

        • Hallo (bin neu hier) und hab da mal ne Frage zum
          ESP8266
          Kann ich mit diesem Modul eine einfache Alarmmeldung per Email automatisch versenden??
          Habe eine Alarmleuchte die nicht in Sichtweite ist. Bei Alarm möchte ich eine Email erhalten. Das ganze ist nicht Zeitkritisch.
          Vielen Dank in Voraus

          • Hallo Kronef,

            das ist kein Problem. Bei Google findest Du zum Suchbegriff „SMTP ESP8266“ Beispiele die zeigen wie es funktioniert.

            Hubert

  10. Hallo Hubert,

    ich bin Arduino Neuling und Teste gerade die erworbenen Komponenten. Bzgl. des WLAN Moduls wollte ich deinen Sketch verwenden. Der lässt sich aber leider nicht übersetzen und meldet

    „Arduino: 1.6.5 (Linux), Platine: „Arduino Uno“

    ESP8266_Uno01_ProgMem.ino: In function ‚void loop()‘:
    ESP8266_Uno01_ProgMem:118: error: ISO C++ forbids comparison between pointer and integer [-fpermissive]
    ESP8266_Uno01_ProgMem:379: error: incompatible types in assignment of ‚int‘ to ‚char [100]‘
    ISO C++ forbids comparison between pointer and integer [-fpermissive]
    aktiviert in Datei > Einstellungen“

    Fehlt hier auf meiner Seite etwas? Wie kann ich das beheben?

    Vielen Dank im Voraus
    Helmut

    • Hallo Helmut,

      welche Statements werden bestandet ? Wie alt ist Dein Download ?

      Ich könnte vermuten Du hast einen sehr alten Download oder hast das Coding mit Cut and Paste aus der WEB-Seite kopiert.

      Die beanstandeten Zeilen könnten folgende sein :

      1.
      Alt falsch:
      void loop() {

       for (i = 0; i < 5; i++) {
         if (buffer_pointer < ‚0‘ || buffer_pointer > ‚9‘) buffer_pointer = 0;
      ; }
      Neu richtig :
       for (i = 0; i < 5; i++) {
         if (buffer_pointer[i] < ‚0‘ || buffer_pointer[i] > ‚9‘) buffer_pointer[i] = 0;
      ; }

      2.
      Alt falsch :

      //————————————————————
      void RECV_Buffer_Clear() {
        for (int i = 0; i < RECV_BUFFER_SIZE; i++) RECV_Buffer = 0;
        while (WIFI_Serial.available())WIFI_Serial.read();
      }
      Neu richtig :

      //————————————————————
      void RECV_Buffer_Clear() {
        for (int i = 0; i < RECV_BUFFER_SIZE; i++) RECV_Buffer[i] = 0;
        while (WIFI_Serial.available())WIFI_Serial.read();
      }
      Im oben angezeigten Listing ist das noch falsch (um die Aufmerksamkeit des Lesers zu überprüfen 🙂 ).

      Hubert

  11. Pingback: Arduino mit Wlan Modul ESP8266 | Unerklärliches am Rande

  12. Es sei nur kurz darauf hingewiesen, dass Port 80 keinesfalls „der Standard für HTML“ ist. HTML ist lediglich eine Beschreibungsprache für das Layout von Webseiten. HTML kann prinzipiell über alle Ports in allen Protokollen übertragen werden.

    Hier geht es um das http Protokoll, welches üblicherweise von Webbrowsern für das Abrufen von Webinhalten verwendet wird. Hier ist Port 80 der Standard.

  13. Hallo ESP Tüftler…
    ich versuche seit einiger Zeit eine „Alarm to Mail“ mit dem ESP8266 zu realisieren…
    Es gibt xxxx Beispiele, aber bis jetzt habe ich keins richtig zum Laufen bewegen können.
    Die neue Arduino Prg. Version 1.5.6. mit ESP Erweiterung läuft super.
    Da fehlt nur noch mein Wunsch-Sketch!
    Wer hat Lust und das Zeug mir zu helfen.
    Bedanke mich in Voraus.

  14. Pingback: ESP8266 WiFi Module | Andreas' Blog

  15. Ein herzliches dankeschön für diese ausführliche erklärung. leider zeigt mir mein modul nach jedem reset an das dass wifi disconnected ist. was kann ich dagegen tun??

    herzlichen dank

  16. Ich mache von anfang an her alles gleich, habe kann den ESP auch über den seriellen Monitor ansprechen.
    wenn ich ihn jetzt mit strom versorge, kommt nach dem öffnen folgende meldung:

    ready
    WIFI DISCONNECT

    für AT+RST

    AT+RST

    OK

    ets Jan 8 2013,rst cause:4, boot mode:(3,6)

    wdt reset
    load 0x40100000, len 1320, room 16
    tail 8
    chksum 0xb8
    load 0x3ffe8000, len 776, room 0
    tail 8
    chksum 0xd9
    load 0x3ffe8308, len 412, room 0
    tail 12
    chksum 0xb9
    csum 0xb9

    2nd boot version : 1.3(b3)
    SPI Speed : 40MHz
    SPI Mode : QIO
    SPI Flash Size : 8Mbit
    jump to run user1

    rlŽƒ[ÿ
    Ai-Thinker Technology Co. Ltd.

    ready
    WIFI DISCONNECT

    und für die firmware abfrage

    AT+GMR

    AT version:0.23.0.0(Apr 24 2015 21:11:01)
    SDK version:1.0.1
    Ai-Thinker Technology Co. Ltd.
    Apr 27 2015 13:55:14

    OK

    ich sitze seit einigen tagen über diesem problem.
    das Netzwerk des ESP sehe ich und er sieht alle anderen netzwerke. nur tun kann er nichts. Die beispiele und auch dein werk bekomme ich nicht rauf…

    • Hallo Basti,
      .
      sende doch mal die Befehlssequenz, die mein Sketch im Wifi_Setup schickt, von Hand und schau auf die Antworten.
      .
      Du hast offenbar eine neuere Firmware, die etwas andere Antworten schickt, als mein Sketch erwartet. Du mußt ggf. die Prüfung der Antworten anpassen oder ggf. die Prüfung ganz entfernen.
      .
      Viel Erfolg Hubert

  17. Pingback: ESP8266 | wer bastelt mit?

  18. Hi Hubert,
    sehr informative Seite. Vielen Dank. Leider kann ich mein Problem damit immer noch nicht lösen. Ich möchte 2 Atmega über 2 ESP miteinander verbinden und Daten austauschen. Die Verbindung ist dabei nicht das Problem – eher der Datenaustausch. Ich bekomme es einfach nicht hin. Hast Du dafür eine gute Idee oder gar eine Anleitung?
    Viele Grüße
    Bernd

    • Hallo Bernd,
      .
      ich vermute du hast eine Verbindung zwischen 2 ESP herstellen können, bist aber beim Versuch Daten via HTTP-Protokoll auszutauschen, gescheitert.
      .
      Hier wäre als Protokoll UDP (User Datagram Protocol) die Lösung. Damit kannst Du Daten mit selbst definierten Format austauschen.
      Leider habe ich damit noch nicht gearbeitet und kann Dir daher keine weiteren Detail sagen.
      Recherchiere im Internet zum Stichwort UDP.
      .
      Hubert

  19. Hi Hubert,
    sehr schöne Anleitung. Ich hab ewig gesucht um festzustellen das man RXT und TXT vertauschen muss um Befehle manuell zu senden.
    Geht das auch anders? Der DUE hat doch zwei USBs, gehts damit besser?
    Mir ist noch aufgefallen dass debug-Ausgaben abgeschnitten werden.
    zB:
    IP
    +CIFSR:APIP,“192.168

    Bei IP fehlt der Rest. Woran liegt das?

    Grüße
    Udo

  20. Hi, Danke für das „Kochbuch“, aber bei kommt bereits ein Fehler beim Kompilieren in Zeile 144, trotz der 2 Änderungen.
    if (buffer_pointer[i] „9“) buffer_pointer[i] = 0;
    Fehlermeldung:
    Arduino: 1.6.6 (Windows 7), Board: „Arduino/Genuino Uno“
    exit status 1
    ISO C++ forbids comparison between pointer and integer [-fpermissive]

    leider komme ich hier nicht weiter.

    • Hallo Jonathan,

      die Zeile müsste jetzt so aussehen :

      for (i = 0; i < 5; i++) {
         if (buffer_pointer[i] < ‚0‘ || buffer_pointer[i] > ‚9‘) buffer_pointer[i] = 0;
      ; }

      …mit einfachen Hochkommatas und Vergleichsoperator..

      Hubert

      • Danke für schnelle Antwort, Der Download Link lädt nur den Sketch vom 22.12.2014. Oder gibt es noch eine Stelle wo der aktuelle Sketch geladen werden kann, die nicht gefunden habe 😉 VG

        • Irgenwie will es bei mir nicht klappen. Uno01_Progmem.ino wird jetzt fehlerfrei kompiliert und hoch geladen. Doch zuvor muß ich doch SSID ausführen (Oder?), und hier klemmt es. Zeile 10 exit status 1 – mySerial does not name a type.
          Nun weiß ich nicht weiter.

          • Hi, ich habe jetzt einen anderen kl. Sketch genommen um SSID und PASS einzustellen. Das funktioniert. Ich habe das ESP Modul auf 19200 Baud umgestellt weil es da bei anderen Test sicher funktionierte.
            Der Sketch Auszug:
            #define SSID „… ssid …“
            #define PASSWORD „… password …“
            #define DEBUG true
            #include
            SoftwareSerial esp8266(11, 12); //RX, TX
            void setup()
            {
            // Open serial communications and wait for port to open:
            Serial.begin(19200);
            // set the data rate for the SoftwareSerial port
            esp8266.begin(19200);
            //Reset Module
            esp8266.println(„AT+RST“);
            esp8266.setTimeout(5000);
            if (esp8266.find(„ready“)) {
            Serial.println(„Reset OK“);
            }
            else
            {
            Serial.println(„Reset Error“);
            }
            //WLAN-Modus = Station
            esp8266.setTimeout(1000);
            esp8266.println(„AT+CWMODE=1“);
            if (esp8266.find(„OK“)) {
            Serial.println(„CWMODE OK“);
            }
            else
            {
            Serial.println(„CWMODE Error“);
            }
            //Connect to WLAN, long Timeout
            esp8266.setTimeout(20000);
            esp8266.println(„AT+CWJAP=\““ + String(SSID) + „\“,\““ + String(PASSWORD) + „\““);
            if (esp8266.find(„OK“)) {
            Serial.println(„WLAN Connect OK“);
            }
            else
            {
            Serial.println(„WLAN Connect Error“);
            }
            ———————-selbst PING zu Google funktioniert—
            Dann der Sketch ESP8266_Uno01_ProgMem.ino
            angepasst RX/TX 11/12 und in Zeile 80
            WIFI_Serial.begin(19200); // org 115200 cjr 19200
            Dann kommt nur im ser. Monitor
            AT+CIPMUX=1
            das war es! Leider. Im Browser ist die Seite nicht zu erreichen. Im WLAN Router ist das Modul weg (war vorher da). Die Reset-Leitung habe ich zw. Uno und ESP Modul getrennt.
            Ich habe auch noch ein ESP Modul mit Original Baudraten Einstellung 115200. Im Test selbiges Ergebnis. Hmmm?

          • Hi Hubert, Sorry jetzt war wieder mal zu schnell auf dem Senden Button. Eine Mail wäre super, Danke.

          • Und das ESP Modul ist doch noch im WLAN Router aktuell aufgelistet, Sorry, für o.g. Gegenteil.

          • … Und plötzlich funktioniert es. Hurra. Ein Fehler war, RX/TX muss eben wirklich auf RX/TX! Das ESP Modul funktioniert bei mir jetzt mit 19200 Baud.
            @Hubert, Mail an mich wäre trotzdem nett. VG

          • Hi, Hubert
            wie müsste der Code aussehen für einen Button -Aktualisieren- und wo?
            Wozu? Wenn 2 Endgeräte auf den Arduino zugreifen kann der aktuelle Zustand nicht ermittelt werden. Durch -Neu Laden- der Webseite wird der Zustand verändert. VG

    • Hallo Jonathan,
      .
      am einfachsten wäre es wenn Du einfach hinter dem Radio-Button „Blinken“ einen weiteren Radio-Button mit dem Value „Nix“ und dem Text „Status abrufen“ einbauen würdest.
      .
      Hubert

    • Hallo zusammen, versuche Verzweifelt einen ESP8266 – 07 an einem PCB Board mit einem Ardunio Nano zu betreiben.
      Ziel ist zum einen eine Art WLAN – TEMP Messer zu bauen, welcher mir die Werte an einen UDP – Server schickt.
      Zum anderen in einem bestehenden Projekt den W5100 gegen den ESP auszutauschen.

      Leider komme ich nur bis:
      AT+CWMODE=2
      AT+RST
      mehr nicht

      • Hallo Flo,
        vermutlich hast Du eine andere FirmwareVersion als ich. Die antwortet anders als das Programm erwartet.

        Entferne einfach alle Prüfungen der Antworten.
        Viel Glück.
        Mehr nicht.
        Hubert

        • Das verstehe ich jetzt nicht! Hab noch experiementiert, kann es sein das das Modul ziemlich auf Spannungsschwankungen reagiert! bekomme aus meinem Modul gerade mal 3.1 Volt raus.

          Hatte mit einem DC Spannungregler versucht und diesen über den 5V Ausgang des Ardunio gelegt, aber auch hier bricht die Spannung auf unter 3.1V zusammen. Die Rote LED leuchtet aber sonst eben nichts!

        • Also Reset geht (Blinkt kurz die Blau LED)

          Wenn ich z.b. SET AP Schreibe dann bekomme ich nach dem ich die AT-RST entfernt habe AT+CWMODE=2
          AT+CWSAP=“myESP01″,“12345678″,8,3
          zurück aber mehr nicht.
          WIe kontrolliere ich die Firmware

  21. Hallo Hubert,
    ich habe mit Freude dieses Projekt umgesetzt. Es funktioniert echt prima. Jetzt wollte ich den Scetch dahingehend ändern, dass ich mit einer Checkbox einen PIN (Pin 10) am UNO schalten kann. Dazu habe ich bereits eine Checkbox mit der entsprechenden Bezeichnung auf der HTML-Seite erstellt. Wenn ich das Formular über den Button abschicke, wird folgendes in der Adresszeile angezeigt:

    http//:192.168.4.1/?LED=Ein&PULS=500&pin10=AN

    Das &pin10=AN wird ja nur mitgeschickt, wenn ich die Checkbox auch anhake. Soweit sollte das ja schon mal richtig sein. Jetzt habe ich aber ein Problem mit der Abfrage. Ich habe es folgendermaßen gemacht (Auszug):
    *************************************************************************************
    if (WIFI_Packet_Length > 0) {
    buffer_pointer = RECV_Buffer;
    if (strncmp(buffer_pointer, „?LED=“, 5) == 0)
    {
    buffer_pointer += 5;
    if (strncmp(buffer_pointer, „Ein“, 3) == 0)
    {
    led_mode = LEDMODE_EIN;
    }
    if (strncmp(buffer_pointer, „Aus“, 3) == 0)
    {
    led_mode = LEDMODE_AUS;
    }
    if (strncmp(buffer_pointer, „Blk“, 3) == 0)
    {
    led_mode = LEDMODE_BLINK;
    }
    buffer_pointer += 3;
    if (strncmp(buffer_pointer, „&PULS=“, 6) == 0)
    {
    buffer_pointer += 6;
    for (i = 0; i < 5; i++)
    {
    if (buffer_pointer[i] ‚9‘) buffer_pointer[i] = 0;
    }

    led_pulsdauer = atoi(buffer_pointer);
    }
    buffer_pointer += 3;
    if (strncmp(buffer_pointer, „&pin10=AN“, 9) == 0)
    {
    digitalWrite(PIN10, HIGH);
    }
    else
    {
    digitalWrite(PIN10, LOW);
    }

    }
    WIFI_Host[0] = 0;
    if (WIFI_Serial.find(„Host: „)) {
    len = WIFI_Serial.readBytesUntil(13, WIFI_Host, 23);
    WIFI_Host[len] = 0;
    }
    HTML_Page(WIFI_Cannel);
    }
    }
    RECV_Buffer_Clear();

    **************************************************************************
    Irgendwie ist da noch der Wurm drin, denn ich bekomme den Pin10 einfach nicht HIGH!?
    Kannst du helfen???

    Vielen Dank
    Torsten

    • Hallo Torsten,

      meine Auswertung der Pulsdauer ist „Quick and dirty“. Sie funktioniert so nur wenn die Pulsdauer der letzte Parameter ist, der ausgewertet wird.

      Grund: Das Zeichen nach der letzten Ziffer des Zahlenwertes wird auf Hex 00 geändert damit das ATOI funktioniert. In Deinen Beispiel ist es das & von &PIN. Ausserdem wird nicht berücksichtigt, wieviel Ziffern eingelesen wurden, also um wieviel Zeichen der Bufferpointer weitergeschoben werden muss.

      Das müsste ins Coding eingearbeitet werden.

      Einfacher wäre es, die Reihenfolge Pulsdauer und PIN10 auf HTML-SEITE und in der Auswerteroutine zu tauschen.

      Hubert

      • Hallo Hubert,
        so langsam habe ich das jetzt mit der Parameterangabe beim Abschicken der Seite verstanden. Ich habe jetzt bereits drei Checkboxen auf meine HTML-Seite platziert, um den PIN4,5 und 6 anzusteuern.
        Jetzt verhält es sich bei Checkboxen ja so, dass diese halt nur bei checked als Parameter mitgeschickt werden. Somit ist nicht immer eindeutig, welcher Parameter als erstes kommt. Daher musste ich auf genau diesen Zustand im Code reagieren. Ich habe es wie folgt erfolgreich umgesetzt:

        if (WIFI_Packet_Length > 0)
        {
        buffer_pointer = RECV_Buffer;
        if (strncmp(buffer_pointer, „?pin04=AN“, 9) == 0)
        {
        buffer_pointer += 9;
        pin_04 = HIGH;
        }
        else
        {
        pin_04 = LOW;
        }

        if ((strncmp(buffer_pointer, „&pin05=AN“, 9) == 0) || (strncmp(buffer_pointer, „?pin05=AN“, 9) == 0))
        {
        buffer_pointer += 9;
        pin_05 = HIGH;
        }
        else
        {
        pin_05 = LOW;
        }

        if ((strncmp(buffer_pointer, „&pin06=AN“, 9) == 0) || (strncmp(buffer_pointer, „?pin06=AN“, 9) == 0))
        {
        buffer_pointer += 9;
        pin_06 = HIGH;
        }
        else
        {
        pin_06 = LOW;
        }
        }

        Der Pointer wird somit nur weiter gezählt, wenn auch der jeweilige Parameter mitgeschickt wurde. Somit ist das Problemchen gelöst 🙂

        Viele Grüße
        Torsten

  22. Hallo Herr Baumgarten,

    super Anleitung, das werde ich ausprobieren, da mein nächstes Projekt danach aussieht, dass es mit arduino und WLan am Besten umgesetzt werden kann.

    Ich habe jetzt beim Durchlesen die Problematik des HTTP Headers „Content-Length“ verstanden. Hier gibt es ab der Protokollversion HTTP 1.1 (Standard heutzutage) die Möglichkeit die Übertragung „chunkweise“ durchzuführen:
    https://en.wikipedia.org/wiki/Chunked_transfer_encoding

    Die Technik ist eigentlich für das Streamen (z.B. Videodaten) erfunden worden, wenn aber der Arduino aufgrund der Speicherbegrenzung hier effizienter arbeiten kann, warum nicht, denn das funktioniert auch für kleine Datenmengen.

    Viele Grüße
    NTR

  23. Hallo…

    sehr cooles Projekt… ich hab das Teil zum laufen bekommen. Hab aber jetzt ein Problem. Ich wollte einen DHT11 abfragen und den Wert auf die WebPage stellen.
    Aber sobald ich die Abfrage des DHT Sensors integriere hab ich ein Problem mit der Host Adresse. Das macht sich bemerkbar beim Absende Button. Wenn der ein paar mal gedrückt wird steht irgendwann Müll in der HostAdresse. Ich denke mal das da ein Zeiger falsch verbogen ist. Wo? in der DHT Library oder wo … konnte ich noch nicht finden.
    Viel leicht können sie mir noch einen Tip geben…

    Danke

    • Hallo Johny,

      ich befürchte ein zu klein definiertes Char-Array oder ähnliches.

      Ohne weitere Informationen muss es bei einer Spekulation bleiben.

      Hubert

  24. Hallo,
    könnten Sie mir bitte mal behilflich sein 🙂
    Ich haben nämlich ein Problem bei der Umsetzung ihres Projektes mit dem ESP8266. Mein Teil läuft nicht sowie ich will. Und zwar: wenn ich die Schaltung identisch Ihrer aufbaue, sodass eine Verbindung zwischen den ESP8266 und dem Arduino Uno R3 entsteht und ich dann bei der Arduino IDE den seriellen Monitor einschalte kommt die Meldung „WiFi shield is not present“. Ich kann nicht „AT“ eingeben, wo dann anschließend „OKAY“ erscheinen sollte.
    Bitte um Hilfe!! Mein Abiturprojekt steht auf dem Spiel.
    Danke inzwischen und mit freundlichen Grüßen
    Hannes

    • Hallo Hannes,
      Wenn Du den ESP anschließt wie oben gezeigt, kannst Du den Serialmonitor des PC nicht verwenden. Du hättest 3 Beteiligte : den Arduino, den ESP und den USB.

      Du kannst die gezeigten AT Kommando mit dem Beispielprogramm Softserial der Arduino ESP testen. Du benötigst jedoch einen Arduino Mega und verwendest statt des Softserial einen der vorhandenen Hardware SerialPorts. Du musst das Beispielprogramm entsprechend anpassen.
      Der Grund : Die Softserial Funktion schafft die Baudrate 115200 nicht.

      Die angegebene Beschaltung funktioniert nur mit dem angegeben Sketch.
      Die DebuggerAusgabe muss z.B. mit einem 2. Arduino vom Softserial eingelesen und kann über USB an den Serialmonitor weitergeleitet werden.

      Hubert

  25. Hallo Hubert,
    Dein Beispiel funktioniert soweit auch mit meinem MEGA. Beim Versuch,
    die HTML-Inhalte deutlich, d.h auf über ca. 2400 byte, zu erweitern,
    kam jedoch kein Inhalt mehr im Browser an und auch das er ESP-01 Modul
    musste mit dem Arduino ‚reset’et werden.
    Ich vermute einen übergelaufenen Puffer und/oder Timing-Probleme irgendwo
    und habe (z.T. etwas naiv und verzweifelt folgendes – erfolglos – versucht:

    1. Mitzählen der im SENDE-Modus (2.Durchlauf) gesendeten Bytes und delay(20),
    wenn das nächste WIFI_Serial.print zu mehr als 2048 bytes führen würde.
    Dann auch Neubeginn der Zählung.
    Ergebnis: keine Verbesserung

    2. Einfügen eines delay(5) oder delay(20) vor/nach jedem WIFI_Serial.print()
    Ergebnis: keine Verbesserung

    3. Willkürliches einfügen von WIFI_Serial.flush() nach jedem WIFI_Serial.print()

    4. Statt HTML-Header mit „content-length:“ einfügen von „Transfer-Encoding: chunked“
    und anpassen aller WIFI_Serial.print()-Aufrufe (Senden der HEX-Länge+CRLF vorweg,
    dann den Inhalt, dann wieder CRLF ud am Schluss wieder einen Leer-Chunk…

    Ich habe die HTML-Seite in Deiner Ursprungsversion umd einen automatischen Refresh
    alle 3s (Meta-tag) erweitert, um Statusinformationen aktualisieren zu können – lief
    problemlos und der Zähler für die Anfragen wurde auch immer schon mitgezählt,
    bei >200 habe ich nicht mehr weiter beobachtet…
    Hardware scheint stabil zu sein (auch RST an 3.3V, saubere Logic-Level Converter,
    Versorgung mit Breadboard-Adapter sollte passen), läuft ja auch.

    Alle Beispiele im WWW sind meist kleine Demos, die unter 2k HTML-Datenerzeugen.

    Wie kann ich größere HTML-Inhalte zuverlässig transferieren und zur Anzeige bringen?

    Es hätte so schön sein können…

    Heiner

    • Hallo Heine,

      man muss in Portionen a 2 KByte senden. Das geht z,B. So

      //———————————————————————
      // in Portionen senden

      my_len = bin_len;
      my_ptr = 0;
      my_send = 0;

      while ((my_len – my_send) > 0) {
      my_send = my_ptr + MAX_PACKAGE_SIZE;
      if (my_send > my_len) {
      client.write(&bin[my_ptr], my_len – my_ptr);
      delay(20);
      my_send = my_len;
      } else {
      client.write(&bin[my_ptr], MAX_PACKAGE_SIZE);
      delay(20);
      my_ptr = my_send;
      }
      }

  26. Hallo Hubert,
    ich habe gerade nach der Firmware gesucht, jedoch keinen download oder ähnliches gesucht ich bin jedoch nicht fündig geworden. Kannst du mir diese geben?
    Mit freundlichen Grüßen,
    Janis

  27. Hallo,
    ich suche beim ESP8266 eine Möglichkeit, um die Funktion/Status eines GPIO zu ermitteln. z.B.ob GPIO als OUTPUT, INPUT oder INPUT_PULLUP konfiguriert wurde

  28. Hallo, danke für die tolle Anleitung.
    Leider klappt es bei mir nicht.
    Bin auch etwas verwirrt wegen der Anbindung.
    Mal sieht man TX->TX mal TX->RX.
    mal mit mal ohne Widerstand / Kondensator.

    habe „eigentlich“ lles so wie oben gemacht. klappt aber nicht bei mir.

    Nochmal ne blöd Frage. Im Arduino IDE muss ich doch Ardunio UNO als Board angeben, nicht ESP Generic 6288?

    Wie könnte ich nach dem Fehler suchen?
    AT liefert nichts.
    Danke

  29. Hallo Hubert, ein großes Dankeschön für diese tolle Seite!

    Bin aber ziemlicher Neuling. Habe den Sketch (ESP8266_Uno01_ProgMem) auf einen Nano gepackt und die LED blinkt, der ESP8266 ist auch im WLAN sichtbar.
    Ich weiß aber nicht, ob ich das Ganze als Station oder AP konfigurieren muss.
    Wo finde ich die zugehörige HTML-Steuerdatei, oder wie muss die aussehen.
    Leider viele Fragezeichen für mich derzeit (noch).

    Viele Grüße, Lutz

    • Hallo Zusammen,
      ich habe mich nun noch mal ausgiebeig mit dem Sketch und seiner Funktion auseinander gesetzt.

      Jetzt ist mir natürlich klar, dass der HTML im Sketch generiert wird, und per Browser und IP-Adresse abgerufen wird.

      Vorher wird natürlich abgefragt, welcher Wifi Modus (AP oder STA), hier beides, aktiv ist.

      Alles habe ich noch nicht verstanden, aber ich möchte es ja mit learning by doing erlernen.

      Der ESP8266 ist wie folgt konfiguriert:
      (SSID + MAC’s sind korrekt da, hier aber verfremdet dargestellt)
      ——————————————————————————
      AT

      00:01:54.968 ->
      00:01:54.968 -> OK
      00:02:27.174 -> AT+RST

      00:02:27.174 ->
      00:02:27.174 -> OK
      00:02:27.174 -> WIFI DISCONNECT
      00:02:27.274 ->
      00:02:27.274 -> ets Jan 8 2013,rst cause:2, boot mode:(3,7)
      00:02:27.274 ->
      00:02:27.321 -> load 0x40100000, len 2408, room 16
      00:02:27.321 -> tail 8
      00:02:27.321 -> chksum 0xe5
      00:02:27.321 -> load 0x3ffe8000, len 776, room 0
      00:02:27.321 -> tail 8
      00:02:27.321 -> chksum 0x84
      00:02:27.321 -> load 0x3ffe8310, len 632, room 0
      00:02:27.321 -> tail 8
      00:02:27.321 -> chksum 0xd8
      00:02:27.321 -> csum 0xd8
      00:02:27.321 ->
      00:02:27.321 -> 2nd boot version : 1.6
      00:02:27.321 -> SPI Speed : 40MHz
      00:02:27.321 -> SPI Mode : QIO
      00:02:27.321 -> SPI Flash Size & Map: 8Mbit(512KB+512KB)
      00:02:27.321 -> jump to run user1 @ 1000
      00:02:27.321 ->
      00:02:27.374 -> ⸮⸮⸮
      00:02:27.421 -> ready
      00:02:29.582 -> WIFI DISCONNECT
      00:02:32.991 -> WIFI CONNECTED
      00:02:33.894 -> WIFI GOT IP
      00:03:48.516 -> AT+CWMODE?

      00:03:48.516 -> +CWMODE:1
      00:03:48.516 ->
      00:03:48.516 -> OK
      00:04:20.845 -> AT+CWLAP

      00:04:22.954 -> +CWLAP:(3,“7xxxxxxx“,-65,“xx:xx:xx:xx:xx:xx“,1,18,0)
      00:04:22.954 -> +CWLAP:(4,“7xxxxxxx“,-55,“xx:xx:xx:xx:xx:xx“,1,11,0)
      00:04:22.954 ->
      00:04:22.954 -> OK
      00:05:25.720 -> AT+CWJAP?

      00:05:25.720 -> +CWJAP:“7xxxxxxx“,“xx:xx:xx:xx:xx:xx“,1,-62
      00:05:25.720 ->
      00:05:25.720 -> OK
      00:06:07.099 -> AT+CIFSR

      00:06:07.099 -> +CIFSR:APIP,“192.168.4.1″
      00:06:07.099 -> +CIFSR:APMAC,“xx:xx:xx:xx:xx:xx“
      00:06:07.099 -> +CIFSR:STAIP,“192.168.0.105″
      00:06:07.099 -> +CIFSR:STAMAC,“xx:xx:xx:xx:xx:xx“
      00:06:07.099 ->
      00:06:07.099 -> OK

      00:18:45.633 -> AT+GMR

      00:18:45.633 -> AT version:1.3.0.0(Jul 14 2016 18:54:01)
      00:18:45.680 -> SDK version:2.0.0(5a875ba)
      00:18:45.680 -> Farylink Technology Co., Ltd. v1.0.0.2
      00:18:45.680 -> May 11 2017 22:23:58
      00:18:45.680 -> OK
      —————————————————————————

      Das ist aus meiner Sicht so i.O. Oder gibt es da Gegenteiliges?

      An diesen 8266 ist ein Arduino-Nano mit dem Sketch (ESP8266_Uno01_ProgMem) gemäß der Beschaltung im Bild 4 angschlossen.

      Leider liefert die Wifi-Setup wohl einen Fehler (LED blinkt) und der Serial Monitor liefert lediglich:
      „00:48:20.146 -> AT+CIPMUX=1“.

      Würde mich über hilfreiche Kommentare sehr freuen.

      Gruß, Lutz

  30. Moin,

    das Ganze funktionierte mit meiner ESP8266 nicht.

    Mein ESP8266 entspricht 100% dem auf oben abgebildeten Foto.
    Damit dieser benutzt werden kann muss aber der Pin CH_PD nachdem der Chip Strom bekommen hat einmal High-Low-High wechseln.

    Meine Version des Chips ist:

    00:44:55.512 -> AT+GMR
    00:44:55.512 ->

    00:44:55.512 -> AT version:1.3.0.0(Jul 14 2016 18:54:01)
    00:44:55.512 -> SDK version:2.0.0(5a875ba)
    00:44:55.512 -> Farylink Technology Co., Ltd. v1.0.0.2
    00:44:55.512 -> May 11 2017 22:23:58
    00:44:55.512 -> OK

    Das Programm mit dem ich dieses erzeugt habe sieht wie folgt aus:

    ———–Programm Beginn

    //9600,19200,38400,57600,115200
    const long baudRate = 115200;
    char c=‘ ‚;
    boolean NL = true;
    void setup()
    {
    Serial.begin(38400);
    Serial.print(„Sketch: „); Serial.println(__FILE__);
    Serial.print(„Uploaded: „); Serial.println(__DATE__);
    Serial.println(“ „);
    Serial2.begin(baudRate);
    Serial.print(„WiFiserial started at „); Serial.println(baudRate);
    Serial.println(“ „);
    }
    void loop()
    {
    // Read from the Module and send to the Arduino Serial Monitor
    if (Serial2.available())
    {
    c = Serial2.read();
    Serial.write(c);
    }

    // Read from the Serial Monitor and send to the Bluetooth module
    if (Serial.available())
    {
    c = Serial.read();
    Serial2.write(c);
    // Echo the user input to the main window. The „>“ character indicates the user entered if (NL) { Serial.print(„>“); NL = false; }
    Serial.write(c);
    if (c==10) { NL = true; }
    }
    }

    ——-Programm Ende

    Den Sketch abladen, Seriellen Monitor öffnen. 38400 Baud einstellen, Sowohl NL als auch CR einstellen. Dann kann man in der oberen Zeile AT Kommandos eingeben und unmittelbar eine Reaktion im Terminalfenster sehen.

    Ein derart einfaches Programm hilft beim Debuggen/ konfigurieren eines jeden Gerätes, das per AT Kommando angesprochen werden kann.

    Jedenfalls mußte ich eine Strippe mehr ziehen und die Programme dahingehend ändern, dass der PinHigh-Low-High durchläuft. Ansonsten reagiert das Ganze nicht auf AT Kommandos.

    • Hallo Gerald,
      vielen Dank, aber das wird mir wohl nicht all zu viel weiterhelfen.
      Der Code liefert mir auch einen Fehler:

      „ESP8266__ber_nano_AT:18:5: error: ‚Serial2‘ was not declared in this scope
      if (Serial2.available())
      ^
      ESP8266__ber_nano_AT:28:1: error: ‚Serial2‘ was not declared in this scope

      Serial2.write(c);

      exit status 1
      ‚Serial2‘ was not declared in this scope“

      Da wüßte ich jetzt auch nicht, was ich tun muss um Serial2 zu definieren.

      btw: Ich habe einen schwarzen ESP8266, den ich direkt über einen FTDI-Adapter anspreche.

      LG, Lutz

      • Hallo Lutz,
        Setze für den ESP8266 die Baudrate auf 115200.
        Benutze statt Serial2 Softserial.
        Lasse alle Prüfungen der Antworten des ESP8266 weg.
        Lasse den Reset weg.
        Viel Erfolg
        Hubert

        • Hallo Hubert,
          vielen Dank, ich habe Geralds Sketch mal angepasst, allerdings weiß ich nicht was Du mit „Prüfungen der Antworten…“ meinst:
          ——————————————————-
          #include
          //9600,19200,38400,57600,115200
          const long baudRate = 115200;
          char c=“ „;
          boolean NL = true;
          SoftwareSerial mySerial(10, 11); // RX, TX

          void setup()
          {
          Serial.begin(2400);
          Serial.print(„Sketch: „); Serial.println(__FILE__);
          Serial.print(„Uploaded: „); Serial.println(__DATE__);
          Serial.println(“ „);
          mySerial.begin(baudRate);
          Serial.print(„WiFiserial started at „); Serial.println(baudRate);
          Serial.println(“ „);
          }
          void loop()
          {
          // Read from the Module and send to the Arduino Serial Monitor
          if (mySerial.available())
          {
          c = mySerial.read();
          Serial.write(c);
          }

          // Read from the Serial Monitor and send to the Bluetooth module
          if (Serial.available())
          {
          c = Serial.read();
          mySerial.write(c);
          // Echo the user input to the main window. The „>“ character indicates the user entered if (NL) { Serial.print(„>“); NL = false; }
          Serial.write(c);
          if (c==10) { NL = true; }
          }
          }
          ——————————————————

          Das Ganze läuft und die Beiden sprechen auch miteinander und ich kann es im Ser. Monitor sehen.
          Allerdings funktioniert es nur, wenn ich den seriellen Monitor auf max. 2400 baud setze, aber selbst hier noch viel Zeichensalat:
          —————————————————–
          Sketch: (Pfad+Datei werden korrekt angezeigt)
          18:21:52.785 -> Uploaded: Sep 17 2019
          18:21:52.878 ->
          18:21:52.878 -> WiFiserial started at 115200
          18:21:53.019 ->
          18:21:57.286 -> AATT++CCWWJJAAPP??

          18:21:57.332 ->
          18:21:57.379 -> +CWJAP:“SSID“,“##:##:##:##:##:##“,0,-68
          18:32:20.470 -> C⸮j⸮H⸮AATT++CCIIFFSSRR

          18:32:20.470 ->
          18:32:20.470 -> +CIFSR:STAIP,“192.168.0/105″
          18:32:20.611 -> +CIFSS:STAMAC,“Y,’V⸮⸮钚⸮º⸮⸮j
          18:32:20.752 ->
          18:32:20.752 -> OK

          ————————————————————————-
          Bin dann nochmals runter auf 1200 baud.
          Das AT+CIFSR habe ich mehrfach getestet, es wir bei der IP oft ein / anstatt . angezeigt, oder auch 104 statt 105, da kann man der Anzeige also nicht so wirklich vertrauen.

          Was aber meine Ursprüngliche Frage war, warum ich mit Deinem Sketch keine Verbindung bekomme, oder besser, Die LED blinkt.
          Soweit ich den Sketch verstehe, zeigt dies ja einen Fehler an.
          Einziger Unterschied ist bei mir die Anschaltung der VCC an den ESP8266, diese kommt bei mir aus einer separaten 3,3V-Spannungsversorgung.

          Vielleicht hast Du da ja noch eine Idee.
          Lutz

          • Hallo Lutz,
            … Lasse alle Prüfungen der Antworten des ESP8266 weg.
            … Lasse den Reset weg
            bezieht sich auf meinen obigen Sketch. Das weglassen der Prüfungen ist erforderlich weil die Antworten des ESP8266 abhängig von der Firmwareversion unterschiedlich.sind.

            Zu dem Sketch von GeraldR63 mit SoftwareSerial statt Serial2 : Es hilft wenn man den Buffer vergrößert.

            Das geht mit :

            #define _SS_MAX_RX_BUFF 128 // RX buffer size

            Das muss vor dem

            #include SoftwareSerial.h

            eingefügt werden.

            Der Defaultwert der Buffergröße ist 64.

            Hubert

  31. Hallo Hubert,
    das mit dem Puffer vergrößern hat leider nicht wirklich etwas gebracht.
    Nach wie vor max. 1200bd möglich, aber auch da immer noch teils Fehler.

    Zu Deinem Sketch:
    Ich nehme an, Du meinst den Prüfungen die „#ifdef WIFI_DEBUG … #endif“-Schleifen?

    Wenn da so korrekt ist, habe ich den Sketch wie folgt angepasst.
    Ist fehlerfrei kompilierbar+hochladbar, aber immer noch blinkt die Lampe, obwohl der 8266 im WLAN sichtbar ist.

    Gruß, Lutz

    —————————————————-
    //————————————————————————–
    // Wifi Modul ESP8266 Beispiel Programm
    //————————————————————————–
    // Basis war das Beispiel von Ray Wang http://rayshobby.net/?p=9734
    //————————————————————————–

    #include
    //
    #define WIFI_DEBUG

    #define WIFI_Serial Serial
    //#define Debug_Serial mySerial

    //#ifdef WIFI_DEBUG
    #include
    SoftwareSerial mySerial(10,11); // RX, TX
    //#endif

    #define WIFI_ERROR_NONE 0
    #define WIFI_ERROR 1

    //—————————————————————————
    // HTML
    int HTML_Content_Length;
    int HTML_Header_Length;
    int HTML_Temp_Length;
    byte HTML_Sende_Mode;
    int HTML_Counter = 0;

    #define HTML_SENDE_MODE_PREPARE 0
    #define HTML_SENDE_MODE_SEND 1

    //—————————————————————————
    // WIFI
    char WIFI_Net[30];
    char WIFI_IP_Adress[20];
    #define PORT 80
    char WIFI_Host[24];
    int WIFI_CWMODE;
    #define CWMODE_STATION 1
    #define CWMODE_ACCESSPOINT 2
    int WIFI_Setup_Error = 0;

    //—————————————————————————
    // Receive-Buffer
    #define RECV_BUFFER_SIZE 100
    char RECV_Buffer[RECV_BUFFER_SIZE];

    //—————————————————————————
    // LED Handling
    #define LEDMODE_AUS 0
    #define LEDMODE_EIN 1
    #define LEDMODE_BLINK 2
    #define LEDPIN 13
    int led_value = LOW;
    int led_mode = LEDMODE_AUS;
    unsigned long led_nextpuls = 0;
    int led_pulsdauer = 500;

    //———————————————————————–
    // Routinen deklarieren
    int WIFI_Setup();
    void RECV_Buffer_Clear();
    void Led_Handling();
    void Set_Led(int p);
    void HTML_Make_Header();
    void HTML_Make_Content();
    void HTML_Send(char * c);
    void HTML_Send_Int(int z);

    void HTML_Send_PROGMEM(const __FlashStringHelper* tx);

    //————————————————————————————–
    void setup() {
    pinMode(LEDPIN, OUTPUT);

    WIFI_Serial.begin(115200);
    WIFI_Serial.setTimeout(5000);

    //#ifdef WIFI_DEBUG
    // Debug_Serial.begin(9600);
    //#endif
    //———————————-
    // 3 sec warten
    delay (3000);

    Set_Led(HIGH);

    WIFI_Setup_Error = WIFI_Setup();

    //#ifdef WIFI_DEBUG
    // if (WIFI_Setup_Error) {
    // Debug_Serial.println(F(„Error“));
    // }
    //#endif

    if (WIFI_Setup_Error) led_mode = LEDMODE_BLINK;
    else Set_Led(LOW);

    WIFI_Serial.setTimeout(20);
    WIFI_Host[0] = 0;
    RECV_Buffer_Clear();
    }
    //————————————————————————–
    void loop() {

    int WIFI_Cannel, WIFI_Packet_Length;
    int i;
    char *buffer_pointer;
    byte len;

    // request: +IPD,ch,len:GET /?LED=xxx&PULS=nnnn … Host: nnn.nnn.nnn.nnn:nnnn 0x0D …

    if (WIFI_Serial.findUntil(„+IPD,“, „\r“)) {

    WIFI_Cannel = WIFI_Serial.parseInt();
    WIFI_Serial.findUntil(„,“, „\r“);
    WIFI_Packet_Length = WIFI_Serial.parseInt();

    if (WIFI_Serial.findUntil(„GET /“, „\r“)) {

    WIFI_Serial.readBytesUntil(13, RECV_Buffer, RECV_BUFFER_SIZE);

    if (WIFI_Packet_Length > 0) {
    buffer_pointer = RECV_Buffer;
    if (strncmp(buffer_pointer, „?LED=“, 5) == 0) {
    buffer_pointer += 5;
    if (strncmp(buffer_pointer, „Ein“, 3) == 0) {
    led_mode = LEDMODE_EIN;
    }
    if (strncmp(buffer_pointer, „Aus“, 3) == 0) {
    led_mode = LEDMODE_AUS;
    }
    if (strncmp(buffer_pointer, „Blk“, 3) == 0) {
    led_mode = LEDMODE_BLINK;
    }
    buffer_pointer += 3;
    if (strncmp(buffer_pointer, „&PULS=“, 6) == 0) {
    buffer_pointer += 6;
    for (i = 0; i < 5; i++) {
    if (buffer_pointer[i] ‚9‘) buffer_pointer[i] = 0;
    }
    led_pulsdauer = atoi(buffer_pointer);
    }
    }
    WIFI_Host[0] = 0;
    if (WIFI_Serial.find(„Host: „)) {
    len = WIFI_Serial.readBytesUntil(13, WIFI_Host, 23);
    WIFI_Host[len] = 0;
    }
    HTML_Page(WIFI_Cannel);
    }
    }
    RECV_Buffer_Clear();
    }
    Led_Handling();
    }

    //———————————————————————-
    int WIFI_Setup() {
    byte len;

    RECV_Buffer_Clear();

    //———————————————————–
    // start server

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CIPMUX“));
    //#endif

    WIFI_Serial .println(F(„AT+CIPMUX=1“));
    delay(10);
    // normale Antwort :
    // „AT+CIPMUX=1“ 0xD 0xD 0xA 0xD 0xA „OK“ 0xD 0xA

    if (!WIFI_Serial.find(„OK“)) {
    return WIFI_ERROR;
    }
    RECV_Buffer_Clear();

    //———————————————————–
    // TCP service aktivieren

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CIPSERVER“));
    //#endif
    WIFI_Serial .print(F(„AT+CIPSERVER=1,“));
    WIFI_Serial.println(PORT);
    delay(10);

    // normale Antwort :
    // „AT+CIPSERVER=1,8080“ 0xD 0xD 0xA 0xD 0xA „OK“ 0xD 0xA

    if (!WIFI_Serial.find(„OK“)) {
    return WIFI_ERROR;
    }

    RECV_Buffer_Clear();

    //————————————————————————-
    // Timeout für automatisches Trennen der Verbindung setzen

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CIPSTO“));
    //#endif

    WIFI_Serial .println(F(„AT+CIPSTO=0“));
    delay(10);
    if (!WIFI_Serial.find(„OK“)) {
    return WIFI_ERROR;
    }

    //—————————————————————————
    // WiFi Modus ermitteln

    RECV_Buffer_Clear();
    WIFI_Net[0] = 0;

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CWMODE?“));
    //#endif

    WIFI_Serial .println(F(„AT+CWMODE?“));
    delay(10);
    // Normale Antwort AT+CWMODE? 0x0D 0x0D 0x0A+CWMODE:1 0x0D 0x0A 0x0D 0x0A OK 0x0D 0x0A

    WIFI_CWMODE = 0;
    if (WIFI_Serial.find(„AT+CWMODE?\r\r\n+CWMODE:“)) {
    WIFI_CWMODE = WIFI_Serial.parseInt();
    }

    //#ifdef WIFI_DEBUG
    // Debug_Serial .print(F(„CWMode:“));
    // Debug_Serial.println(WIFI_CWMODE);
    //#endif

    if (WIFI_CWMODE == 0) {
    return WIFI_ERROR;
    }

    //—————————————————
    // Ich bin Station. In welchem Netz bin ich ?

    if (WIFI_CWMODE == CWMODE_STATION) {

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CWJAP?“));
    //#endif

    WIFI_Serial .println(F(„AT+CWJAP?“));
    delay(10);
    // Normale Antwort AT+CWJAP? 0x0D 0x0D 0x0A +CWJAP:““ 0x0D 0x0A 0x0D 0x0A OK 0x0D 0x0A

    len = 0;
    WIFI_Net[0] = 0;
    if (WIFI_Serial.find(„AT+CWJAP?\r\r\n+CWJAP:\““)) {
    len = WIFI_Serial.readBytesUntil(‚\“‚, WIFI_Net, 20);
    WIFI_Net[len] = 0;
    }

    if (len > 0) {
    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„Netzwerk:“));
    // Debug_Serial.println(WIFI_Net);
    //#endif
    }
    else {
    return WIFI_ERROR;
    }
    }
    //——————————————
    // Ich bin Accesspoint, wie heisse ich ?
    if (WIFI_CWMODE == CWMODE_ACCESSPOINT) {

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CWSAP?“));
    //#endif

    WIFI_Serial .println(F(„AT+CWSAP?“));
    delay(10);
    // Normale Antwort AT+CWSAP? 0x0D 0x0D 0x0A +CWSAP:“MyESP“,
    // „12345678“,8,3 0x0D 0x0A 0x0D 0x0A OK 0x0D 0x0A
    len = 0;
    WIFI_Net[0] = 0;
    if (WIFI_Serial.find(„AT+CWSAP?\r\r\n+CWSAP:\““)) {
    len = WIFI_Serial.readBytesUntil(‚\“‚, WIFI_Net, 20);
    WIFI_Net[len] = 0;
    }

    if (len > 0) {
    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„Netzwerk:“));
    // Debug_Serial.println(WIFI_Net);
    //#endif
    }
    else {
    return WIFI_ERROR;
    }
    }

    //———————————————————–
    // Get IP Adress

    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„AT+CIFSR“));
    //#endif

    WIFI_Serial .println(F(„AT+CIFSR“));
    delay(1000);

    // Normale Antwort z.B.
    // AT+CIFSR 0xD 0xD 0xA 192.168.178.26 0xD 0xA

    len = 0;
    WIFI_IP_Adress[0] = 0;
    if (WIFI_Serial.find(„AT+CIFSR\r\r\n“)) {
    len = WIFI_Serial.readBytesUntil(‚\r‘, WIFI_IP_Adress, 20);
    WIFI_IP_Adress[len] = 0;
    }
    //#ifdef WIFI_DEBUG
    // if (len > 0) {
    // Debug_Serial .println(F(„IP“));
    // Debug_Serial.println(WIFI_IP_Adress);
    // }
    //#endif
    if (len == 0) {
    return WIFI_ERROR;
    }
    //
    //#ifdef WIFI_DEBUG
    // Debug_Serial .println(F(„Setup okay“));
    //#endif

    return WIFI_ERROR_NONE;
    }

    //———————————————————————-

    void HTML_Page(int WIFI_Cannel) {

    HTML_Counter++;

    //#ifdef WIFI_DEBUG
    // Debug_Serial.print(F(„Zaehler: „));
    // Debug_Serial.println(HTML_Counter);
    //#endif

    HTML_Sende_Mode = HTML_SENDE_MODE_PREPARE;

    HTML_Temp_Length = 0;
    HTML_Make_Content();
    HTML_Content_Length = HTML_Temp_Length;

    HTML_Temp_Length = 0;
    HTML_Make_Header();
    HTML_Header_Length = HTML_Temp_Length;

    WIFI_Serial.print(F(„AT+CIPSEND=“));
    WIFI_Serial.print(WIFI_Cannel);
    WIFI_Serial.print(F(„,“));
    WIFI_Serial.println(HTML_Header_Length + HTML_Content_Length);

    delay(20);

    RECV_Buffer_Clear();

    HTML_Sende_Mode = HTML_SENDE_MODE_SEND;
    HTML_Make_Header();
    HTML_Make_Content();

    delay(10);
    }

    //—————————————————————————
    void HTML_Make_Header() {

    HTML_Send_PROGMEM(F(„HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: close\r\n“));
    HTML_Send_PROGMEM(F(„Content-Length:“));
    HTML_Send_Int(HTML_Content_Length);
    HTML_Send_PROGMEM(F(„\r\n\r\n“));
    }

    //—————————————————————————
    void HTML_Make_Content() {

    HTML_Send_PROGMEM(F(“ Arduino Steuerung\n“));

    HTML_Send_PROGMEM(F(„“));

    HTML_Send_PROGMEM(F(„Arduino Steuerung“));

    HTML_Send_PROGMEM(F(„\nHubbie’s Arduino Uno“));

    HTML_Send_PROGMEM(F(„Led : „));
    switch (led_mode) {
    case LEDMODE_AUS:
    HTML_Send_PROGMEM(F(„aus“));
    break;
    case LEDMODE_EIN:
    HTML_Send_PROGMEM(F(„ein“));
    break;
    case LEDMODE_BLINK:
    HTML_Send_PROGMEM(F(„blinkt“));
    break;
    }
    HTML_Send_PROGMEM(F(„\n“));

    //————————————–
    // Aufrufzaehler
    HTML_Send_PROGMEM(F(„Aufrufzähler = „));
    HTML_Send_Int(HTML_Counter);

    HTML_Send_PROGMEM(F(„“));

    HTML_Send_PROGMEM(F(„“));

    HTML_Send_PROGMEM(F(„Led schalten :“));

    if (led_mode == LEDMODE_EIN) {
    HTML_Send_PROGMEM(F(“ Einschalten“));
    HTML_Send_PROGMEM(F(“ Ausschalten“));
    }
    else
    {
    HTML_Send_PROGMEM(F(“ Einschalten“));
    HTML_Send_PROGMEM(F(“ Ausschalten“));
    }

    HTML_Send_PROGMEM(F(“ Blinken“));

    HTML_Send_PROGMEM(F(„     Plusdauer: mSec“));
    HTML_Send_PROGMEM(F(„“));

    //————————————–
    // Absende-Knopf

    HTML_Send_PROGMEM(F(„“));
    HTML_Send_PROGMEM(F(„“));
    HTML_Send_PROGMEM(F(„“));
    }

    //—————————————————————————
    void HTML_Send_Int(int p_int) {
    char tmp_text[8];
    itoa(p_int, tmp_text, 10);
    HTML_Send(tmp_text);
    }

    //—————————————————————————
    void HTML_Send(char * p_text) {
    HTML_Temp_Length += strlen(p_text);
    if (HTML_Sende_Mode == HTML_SENDE_MODE_SEND) {
    WIFI_Serial.print(p_text);
    }
    }

    //—————————————————————————
    void HTML_Send_PROGMEM(const __FlashStringHelper* p_text) {

    HTML_Temp_Length += strlen_P((const char*)p_text);
    if (HTML_Sende_Mode == HTML_SENDE_MODE_SEND) {
    WIFI_Serial.print(p_text);
    }
    }

    //————————————————————
    void RECV_Buffer_Clear() {
    for (int i = 0; i led_nextpuls) {
    led_nextpuls = millis() + (unsigned long)led_pulsdauer;
    if (led_value == LOW) Set_Led(HIGH);
    else Set_Led(LOW);
    }
    }

    //——————————————————————–
    void Set_Led(int p) {
    led_value = p;
    digitalWrite(LEDPIN, led_value);
    }

    • Hallo Lutz,
      so war das nicht gemeint.

      Mir geht es um Prüfungen der Antwort des ESP8266 dieser
      Art :
      WIFI_Serial .println(F(„AT+CIPSTO=0“));
      delay(10);
      if (!WIFI_Serial.find(„OK“)) {
      return WIFI_ERROR;
      }

      Es könnte sein, das Dein ESP826U eine andere Antwort sendet. Z.B.
      Ok statt OK.
      Unsere Freunde im fernen Osten sind da sehr kreativ.
      Ändere also diese Stelle so:
      WIFI_Serial .println(F(„AT+CIPSTO=0“));
      delay(10);
      // if (!WIFI_Serial.find(„OK“)) {
      // return WIFI_ERROR;
      // }
      Sinngemäß alle anderen Prüfungen der Antworten des ESP8266 ändern.
      Hubert

      • Hallo Hubert,
        vielen Dank für Deine Hilfe!
        Ich habe es jetzt soweit geändert, LED blinkt aber immer noch.

        Im Serail-Monitor zeigt sich Folgendes:
        00:48:54.148 -> AT+CIPMUX=1
        00:48:54.148 -> AT+CIPSERVER=1,80
        00:48:54.195 -> AT+CIPSTO=0
        00:48:54.195 -> AT+CWMODE?
        00:48:59.256 -> AT+CIFSR
        Die AT-Kommandos gehen wohl raus, aber die Antworten fehlen.
        Lutz

        • Hallo Lutz,
          ich habe den Eindruck Du schickst die AT KOMMANDOS für den ESP8266 an den PC Monitor statt an den ESP. Alles wa Du oben protokolliert hast ist für den ESP bestimmt.
          Hubert

          • Hallo Hubert,
            ich habe den Fehler gefunden. Leider habe ich als wie gesagt noch ziemlicher Anfänger die Anschaltung missverstanden.
            Anstatt den ESP an die echten RX/TX-Pins anzuschließen, hatte ich diese an den SoftwareSerial-Pins 10+11.
            Mir waren da Zweifel gekommen, da in Deinem Anschaltbild ja auch die „echte“ Bezeichnung RX/TX gezeigt ist.
            Da mir noch das tiefere Verständnis vieler Passagen im Sketch fehlt/e, dachte ich, dass mit RX/TX am Uno, ja doch wohl nur die Software-Serial Pins 10+11 gemeint sein können.
            Fataler Irrtum, sorry.

            Nun die gute Nachricht: Es läuft und ich kann die LED per Webseite Steuern 🙂

            Nach dem Umklemmen auf die richtigen Pins musste ich aber am ESP noch ein mal Pin CHPD kurz von VCC trennen und un wieder anlegen, dann ging es.

            Nun habe ich die Grundlage, mein aktuelles Projekt einer Gewächshaus Lüftung/Heizungssteuerung, welche bereits mit einem Uno läuft, per Wifi abzufragen bzw steuern zu können.
            Datenlogging wäre auch fein, aber alles nach und nach.

            Da werde ich wohl auch noch viel implementieren und lernen müssen, aber mit HTML kenne ich mich wenigstens etwas besser aus.

            Nochmals meinen ganz lieben Dank!
            Lutz

  32. Hallo, ich mal wieder.
    Seit dem letzten Stand, dass der geändete Sketch bei mir lief, habe ich nun alle meine Variablen- und Routinen-Definitionen, sowie die Routinen selbst in den Sketch übernommen. Alles jeweils hinter den Teilen des Sketches hier.
    Habe dabei auch geprüft, dass keine Variablen doppelt benutzt werden und sich in die Quere kommen.
    Ebenso habe ich meine Setup-Passagen im Setup platziert. (Alles hinter die aus dem Sketch hier)
    -> Sketch läuft, LED lässt sich umschalten, oder auch Blinkfrequenz ändern.

    Test mit der ersten eigenen Routine im Loop (wieder dahinter):
    Webseite läuft, Umschalten ist 1x möglich, danch wird nach dem Absende-Button die Seite 192.168.0.0 aufgerufen anstatt der 105, was natürlich zum HTML-Fehler führt.

    Vermute mal, dass hier irgendwas im Recieve-Buffer oder dessen Pointer „verbogen“ wird, weiß aber leider nicht wo ich ansetzen muss.
    Oder ist das etwas Zeitkritisch?

    Meine Routine um die es geht, liest über „OneWire.h“ und „DallasTemperature.h“ zwei Dallas DS18B20 Temperatur-Sensoren aus.
    Sobald ich die Routine im Loop auskommentiere, läuft wieder alles normal.

    Meine Routine anbei:
    void readTemps(){
    // Aufruf der Funktion sensors.requestTemperatures()
    // Dadurch werden alle Werte abgefragt.
    // Serial.print(„Abfrage der Temperatur… „);
    sensors.requestTemperatures();
    // Serial.println(„DONE“);

    // Ausgabe der Daten für jeden Sensor
    for(int j=0 ;j<numberOfDevices; j++) {
    float tempC = sensors.getTempCByIndex(j);
    //Übergabe der Sensorwerte an tempC0/1
    tempC0 = sensors.getTempCByIndex(0); //Blau/Innen
    tempC0 = tempC0 – 0.25 + OffsetTC0; // Anpassung Exemplarstreuung von 0,5°C
    tempC1 = sensors.getTempCByIndex(1); //ohne/Außen
    tempC1 = tempC1 + 0.25; // Anpassung Exemplarstreuung von 0,5°C
    //serielle Ausgabe
    // Serial.print("Sensor ");
    // Serial.print(i, DEC);
    // Serial.print(" hat Grad Celsius: ");
    // Serial.println(tempC);
    } //Ende der for-schleife

    // Serial.print("tempC0 = ");
    // Serial.println(tempC0,2);
    // Serial.print("tempC1 = ");
    // Serial.println(tempC1,2);
    } //Ende readTemps()

    Vielleicht hat ja jemand eine Idee.
    Lutz

    • Hallo Lutz,
      das lesen der Temperatur mit One wire ist zeitfressend.
      Gib dem ESP Zeit zum durchatmen mit
      delay(10);
      nach 
      sensors.requestTemperatures();
      und
      sensors.getTempCByIndex(j);

      Hubert

      • Hallo Hubert,
        vielen Dank erst mal, hat aber leider nicht geholfen. Habe es auch mal mit 5 und 20 ms probiert.

        Interessant ist im Seitenquelltext des Bowsers, dass sich mit jedem neuladen der HTML-Seite, die IP-Adresse ändert, oder unvollständig ist, oder auch teils völliger Schrott drin steht.

        Quelltext:
        Arduino Steuerung
        Arduino Steuerung
        Hubbie’s Arduino UnoLed : ein
        Aufrufzähler = 6Led schalten : Einschalten Ausschalten Blinken     Plusdauer: mSec
        Hier fehlte die 105, bei anderen Fällen z.B.:
        „http://pgrade-Ins“
        „http://e-Requests“
        „http://lk&PULS=50“
        „http://“

        Gruß Lutz

        • Oops, jetzt nach dem Absenden sehe ich, dass die komplette HTML-Ausgabe ja gar nicht dargestellt wird.
          Auf jeden Fall sind die kompletten Strings bezüglich der LED Schaltfunktionen, Aufrufzähler, Ansendebutton alles korrekt.
          Nur bei der IP gibt es Probleme.
          Lutz

          • Tja, irgendwie scheint es hier nicht weiter zu gehen, ich kann Hubert natürlich auch nicht nur mit meinem Problem belämmern.

            Werde einen anderen Weg suchen müssen, mein Projekt an den Start zu bekommen, wenn auch dieser Ansatz so aussichtreich aussah.

            Ich kann es leider nicht selbst lösen, nicht weil ich nicht suchen und probieren mag, aber ich weiß einfach nicht wo ich anfangen soll, zu suchen.

            Dazu bin ich einfach zu frisch in dem Bereich unterwegs.

            Schade, war ein toller, resourcenschonender Ansatz, aber ich bin da wohl zu blöd, das Problem genauer lökalisieren zu können.

            Werde mein Propjekt wohl auf ganz andere Beine stellen müssen (node-mcu), auch wenn das da nicht weniger steinig sein wird.

            Vielen Dank trotzdem soweit bis hier,
            Lutz

  33. Na, einen Versuch mache ich noch:
    Über die SoftwareSerial-Ausgabe bekomme ich folgende Angaben:
    —————————————————————-
    AT+CIPMUX
    AT+CIPSERVER
    AT+CIPSTO
    AT+CWMODE?
    CWMode:1
    AT+CWJAP?
    Netzwerk:
    ******** (wird korrekt angezeigt)
    AT+CIFSR
    IP
    +CIFSR:STAIP,“192.16 (hier fehlt der Rest, es wäre 192.168.0.105)
    Setup okay
    Zaehler: 1
    ————————————————————-
    Das Setup ist OK, die Seite ist auch unter 192.168.0.105 erreichbar, hat aber im Quelltext für die Rückmeldung per Absende-Button:
    ACTION=“http://“

    An irgendeiner Stelle wird hier die IP nicht richtig übergeben, aber ich weiß nicht wo.
    Würde mich sehr freuen, falls doch jemand eine Idee hat.
    Lutz

    • Halo Lutz,

      vermutlich wird das Feld WIFI_Host nicht (mehr) gefüllt. Du kannst es bei der HTML-Ausgabe weglassen. Dann fügt der Internetbrowser den Wert automatisch ein.

      Hubert

      • Hallo Hubert,

        ich nehme an, Du meinst diesen Teil:

        HTML_Send_PROGMEM(F(„“));

        Egal ob ich nur die mittlere Zeile weglassse, oder den gesamten Block,
        der Browser trägt da nichts von alleine ein.

        Aber noch mal dahin, warum die IP nicht oder fehlerhaft gelesen wird.
        In dienem Sketch unter dem Punkt Get IP

        WIFI_Serial.println(F(„AT+CIFSR“));
        delay(1000);

        // Normale Antwort z.B.
        // AT+CIFSR 0xD 0xD 0xA 192.168.178.26 0xD 0xA

        Steht die normale Antwort
        Diese Antwort weicht bei mir ab:
        IP
        +CIFSR:STAIP,“192.16
        (jeweils mit einem CRLF dahinter)
        Ich behme daher an, dass der Buffer falsch ausgelesen wird, da die Antwort eine andere Länge hat.

        Wäre dann dieser Part anzupassen? :
        WIFI_Host[0] = 0;
        if (WIFI_Serial.find(„Host: „)) {
        len = WIFI_Serial.readBytesUntil(13, WIFI_Host, 23); // War (13, WIFI_Host, 23)
        WIFI_Host[len] = 0;
        }

        Lutz

Schreibe einen Kommentar zu Franz Krone Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

I accept that my given data and my IP address is sent to a server in the USA only for the purpose of spam prevention through the Akismet program.More information on Akismet and GDPR.

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.