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.
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.
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.
Hier die Beschaltung :
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ä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("     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.
Vielen Dank für den schönen Post – nach den Feiertagen schaue ich mir das Modul mal genauer an 🙂
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
Meine Bestellung aus China ist leider noch nicht angekommen,
bin schon gespannt das ganze auszuprobieren.
Ich werde dann mal berichten.
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
Pingback: Review Dorkbot Januar 2015 | Dingfabrik Köln e.V. | Erzbergerplatz 9 | 50733 Köln
Hallo Hubert,
wie verbindest Du denn Deinen PC mit dem Arduino? Tx und Rx sind ja schon für den ESP belegt….
VG
Olaf
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
Ist der Kondensator zwischen 3.3V und GND ein Elko oder Tantalum?
Vielen Dank
Elko.
Gerne
.
PS. Deutliche Twitterschäden
Eine wirklich erstklassige Anleitung! Ich werde sie gleich in unsere nächste Sendung RL045 am Freitag aufnehmen!
PS.: Vielleicht mögt ihr ja in der Bücher-Sektion auch auf mein Buch hinweisen? Würde mich sehr freuen!! Gruß, Markus
http://rheinwerk-verlag.de/roboter-bauen-mit-arduino_3642/ (ehemals GalileoPress)
Hallo Hubert,
sehr schön gemacht, das wird vielen weiterhelfen.
Wir wollen das Modul für ein Webinterface nutzen, um unseren Rasenroboter auch über das Wlan ansprechen zu können.
Ist halt sehr günstig. 😉
Grüße Markus
http://www.ardumower.de
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
Hallo Ulrich,
.
Du sagst : … die Daten … gehen nicht raus.
.
Hast Du mit einem Scope den Arduino Tx gemessen?
.
Hubert
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
Schönes Beispiel!
Darf man hier auch dumme Fragen stellen?
Was bedeutet programmiertechnisch in deinem HTML-Teil das F in println(F(
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
Vielen Dank!
Inzwischen antwortet mein ESP8266 leider nicht mehr.
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 Turtle,
.
der Schlüssel zur Lösung Deiner Aufgabenstellung liegt im richtigen HTML. Liest Dir bei http://wiki.selfhtml.org/wiki/ alles zum Suchbegriff Button durch.
.
Hubert
Hallo Hubert,
werde ich probieren. Ich hoffe ich werde fündig.
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
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.
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/
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 Caude,
hast Du den CH_PD an +3.3V und sicherheitshalber auch den Reset ?
Hubert
vielen dank es funktioniert jetzt
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
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
Pingback: Arduino mit Wlan Modul ESP8266 | Unerklärliches am Rande
Hallo,
woher bekomme ich die „#include “ ?? kompiliert sonst nicht.
Danke
Hallo Gerry,
.
welches include wird vermisst ?
.
Hubert
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.
Danke für den Hinweis. Ich habe das richtig gestellt.
Hubert
bei allen Beispielen kann ich die Softwareserial.h nicht eingebunden werden???
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.
Pingback: ESP8266 WiFi Module | Andreas' Blog
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
Hallo Basti,
.
bitte beschreibe genau was Du machst.
.
Hubert
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
Pingback: ESP8266 | wer bastelt mit?
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
Vielen Dank Hubert,
da werde ich mich mal danach auf die Suche machen. Mal sehen wie weit ich komme.
Bernd
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
Das mit der IP(debug) hat sich erledigt…andere Antwort.
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
Danke Hubert, Button werde ich so einbauen. Ich wünsche einen rutschfreien Wochenstart. VG Jonathan
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!
Bei kurzeitigem Reset (auf GND) muss die blaue LED kurz leuchten.
VG
Hallo Flo,
sounds like RIP-Mode.
Not more.
Hubert
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
AT+GMR
Mehr nicht.
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
Wo finde ich diese Firmwareversion 0901 bzw. 0922?
Gruß
Werner
Hallo Werner,
die aktuelle Firmware für den ESP8266 findest Du hier :
http://bbs.espressif.com/viewtopic.php?f=46&t=2198
Gruss
Hubert
Den Link kenne ich. Ich suche aber die Version mit der dieses beispiel hier läuft
gruß
Werner
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
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
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
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;
}
}
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
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
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
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
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.heingefügt werden.
Der Defaultwert der Buffergröße ist 64.
Hubert
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
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
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