Mit Geräten über WLAN kommunizieren ESP8266

Elektronik Eigenbau und anderes
Antworten
asterix
Beiträge: 109
Registriert: 23.05.2018, 08:24

29.07.2018, 10:37

Nachdem auch derzeit mal wieder Betrüger unterwegs sind, die irgendwelche Wunderchips als Werkzeug für die Steuerung ihrer Betrugskisten  vortäuschen, lohnt es sich einmal in die Chip-Thematik einzuarbeiten. Wunderchips gibt es natürlich nicht. Nur Betrüger die regelmäßig welche  behaupten. Mit Chips lassen sich über Schaltvorgänge Ablaufsteuerungen realisieren, die man früher mühsam über Schaltvorgänge mit Relais und  Schützen realisiert hat. Die Masse an Schaltgliedern die damals eine Turnhalle füllen konnten, passen jetzt plötzlich auf einen winzigen Chip.  Das was man früher mühsam über Verbindungsdrähte realisieren musste, das kann man in der Chip basierten Technik über Programme beschreiben die  dann einfach auf einen Chip aufgespielt werden. Der Schulwissenschaft sei Dank 8-) So ein kleines "Wunder" ist heutzutage schon für knapp 3€  zu haben. Und das notwendige Wissen zum Umgang mit den Dingern ist überall im Netz frei zugänglich. Dank vieler Autoren die in der Richtung  unterwegs sind :thumbup: .
 
Das klassische Board fürs Hobby ist eigentlich das Arduino-Board. Mit zusätzlicher Hardware lässt sich ein Arduino auch ins heimische Netz  einbinden. Es gibt inzwischen in der Preisklasse aber auch Boards die einen Mikrocontroller mit Funkanbindungsmöglichkeit haben. Der ESP8266  dürfte der gebräuchlichste davon sein. Mit 11 nutzbaren Digital-E/A-Ports und einem Analogen Eingang ist er zwar etwas dürftiger ausgestattet  als der Arduino,  die CPU wird aber in der Regel mit 80MHz getaktet, was dann wieder andere Vorteile gegenüber dem Arduino bringt. Das  schönste, der lässt sich über die Arduino-IDE genau so programmieren wie der Arduino. Allerdings muss man dazu erst noch die entsprechenden  Boards in der IDE installieren.  Das funktioniert aber ziemlich problemlos. Eine Beschreibung dazu findet man hier. Eine kurze Übersicht zur Technologie  findet man hier

Ich bin auf das Board gestoßen, als ich nach einer Möglichkeit gesucht habe, Daten möglichst einfach drahtlos auf meinen Rechner zu  übertragen. Das Modul lässt sich ganz einfach ins heimische WLAN einbinden. Über eine kurzes Programm kann man dann vom PC aus drahtlos auf  das Board zugreifen.

Zuerst der ESP als Server und der PC als Client.

PC_Client__ESP_Server.jpg
PC_Client__ESP_Server.jpg (154.99 KiB) 231 mal betrachtet

Ich habe mir im ersten Anlauf einen ESP8266D1 MINI besorgt. Mit einem kleinen Programm, wahrscheinlich der simpelste Server der Welt.

Board_Basis_Server.jpg
Board_Basis_Server.jpg (224.29 KiB) 231 mal betrachtet

Zum Programmieren wird das Board über ein Micro USB-Kabel mit dem Rechner verbunden. Aber Vorsicht, die meisten Kabel für Smartphones  funktionieren nicht, weil die intern nur Verbindungen für die Stromversorgung haben.

Der ESP ESP8266 fungiert bei der Methode als Server. Mit dem Programm loggt sich das Board in den heimischen Router ein. Dazu muss der  entsprechende Name des Netzwerks und das Passwort im Programm unter "ssid" und "password" eingetragen werden.

Code: Alles auswählen

#include <ESP8266WiFi.h>

const char* ssid = "Name des WLAN-Netzwerks";
const char* password = "1234567890";

int rt_ledPin=D2;
int gr_ledPin=D1;
int ge_ledPin=D5;

// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

void setup() {
Serial.begin(9600);
pinMode(gr_ledPin, OUTPUT);
pinMode(rt_ledPin, OUTPUT);
pinMode(ge_ledPin, OUTPUT);
digitalWrite(rt_ledPin, HIGH);
digitalWrite(gr_ledPin, LOW);
delay(10);
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
digitalWrite(gr_ledPin, HIGH);
digitalWrite(rt_ledPin, LOW);
digitalWrite(ge_ledPin, LOW);
Serial.println("");
Serial.println("WiFi connected");
server.begin();
Serial.println("Server started");
Serial.println(WiFi.localIP());
}


void loop()
{
WiFiClient client;
if (!(client = server.available())) // Client angemeldet?
return;
digitalWrite(ge_ledPin,HIGH);
unsigned long time0= millis();
while(!client.available())
{
if((millis()-time0) > 5000)// Verbindung abgebrochen;
{
digitalWrite(ge_ledPin, LOW);
return;
}
delay(1);
}
String a = client.readStringUntil('\r');
client.flush();
String s="Antwort vom Server auf"+a+"\r";
client.print(s);
client.flush();
delay(1);
digitalWrite(ge_ledPin, LOW);
}
Wenn das Programm erfolgreich aufgespielt wurde, sollte sich das Board nach einem Druck auf den Reset-Knopf ins WLAN einwählen. Dabei leuchtet  zunächst die rote LED. Wenn die Verbindung zum Router dann steht, geht die rote LED aus und die grüne LED leuchtet. Das Board holt sich vom  Router eine Internetadresse. Die wird im seriellen Monitor angezeigt.  Die gelbe LED leuchtet, wenn ein Client sich beim Server meldet um mit  ihm zu kommunizieren. Die Stromversorgung lässt sich nach der Programmierung am einfachsten über einen Akku mit USB-Ausgang realisieren.

Basis_M1.jpg
Basis_M1.jpg (17.16 KiB) 231 mal betrachtet

Wenn das Einloggen funktioniert, braucht man nur noch einen Client der dem Server dann Anfragen stellen kann oder Anweisungen geben kann.  kann. Da genügt ein kurzes c++ Programm das über die ausgegebene IP-Adresse mit dem Board kommuniziert.

Code: Alles auswählen

using namespace std;

/*
getestet mit mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0 in CodeBlocks
libws2_32.a muss mit eingebunden werden.
Infos: http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/c++_windows_sockets
*/


#include <iostream>
#include <ostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <winsock.h>


void SocketError()
{
::std::cerr << "Fatal Error" << '\n';
WSACleanup();
::std::system( "PAUSE" );
exit(0);
}


char* ip = "192.168.178.33";
int port = 80;

string Anfrage(struct sockaddr *address,string anfrage)
{
SOCKET sock;
const int BUF_LEN=10000;
char File_Buf[ BUF_LEN ];
int r;
if(( sock = socket( AF_INET, SOCK_STREAM, 0 ))== INVALID_SOCKET )
SocketError();
if( connect( sock,address, sizeof( struct sockaddr )))
SocketError();
send( sock,anfrage.c_str(), strlen(anfrage.c_str()),0 );
for(string antwort="";;antwort+=File_Buf)
{
memset (File_Buf,0,BUF_LEN);
r=recv( sock, File_Buf,BUF_LEN, 0 );
if(r < 0)
SocketError();
else if(r == 0)
{
closesocket(sock);
return antwort;
}
}
}



int main()
{
struct sockaddr_in address;
struct hostent * host;

WSADATA wsaData;
if(WSAStartup(MAKEWORD(2,2),&wsaData) !=0)
::std::cout << "WSAStartup failed\n";
address.sin_family = AF_INET;

address.sin_port = htons(port);
::std::cout << "Connecting to host\n";
if(!( host = gethostbyname( ip )))
SocketError();
address.sin_addr.s_addr=*(( unsigned long * )host->h_addr);
for(int n=0; ;++n)
{
for(int i1=0;i1 < 4;++i1)
{
string Antwort=Anfrage(( struct sockaddr * )&address,string(" Anfrage ")+to_string(i1)+string(" vom Client \r"));
::std::cout << Antwort << '\n';
}
::std::cout << "\n" << "2 Sekunden warten\n" << '\n';
Sleep(2000);
}
WSACleanup();
::std::system( "PAUSE" );
}

Das Programm sendet alle 2 Sekunden 4 Anfragen an das Board. Das Board schickt dann eine Antwort zurück. Die Ausgabe des Client-Programms  sieht dann wie folgt aus:

Basis_M2.jpg
Basis_M2.jpg (108 KiB) 231 mal betrachtet

Die IP-Adresse wird vom Router vergeben, wenn das Board sich einloggt. Die kann u.U. von Fall zu Fall verschieden  sein. Im Router lässt sich  aber in der Regel eine feste Adresse einstellen.

Ich habe mir inzwischen auch das NodeMCU V3.1 -Board besorgt. Das funktioniert allerdings nur mit zusätzlicher Stromversorgung richtig. Die  Versorgung über USB reicht zumindest bei meinem Rechner nicht aus. Das Board zieht etwa 90 mA. Mein ESP8266D1 MINI Board zieht etwa 70mA. Eine  Recherche im Netz hat dann ergeben, dass derartige Probleme beim ESP8266 öfters auftreten, weil der je nach Betriebsart auch schon einmal  kurzzeitig 350mA zieht. Eine reguläre Stromversorgung schafft da aber immer Abhilfe. Beim Betrieb als Server oder Client im WLAN braucht man  die in der Regel ja ohnehin.

So ein Server ist hauptsächlich für Steuerungszwecke recht gut geeignet. Der wartet einfach bis ein Client sich bei ihm meldet und führt dann  aus, was der vorgibt. Für Fernsteuerungen ist die Methode sehr gut zu gebrauchen.  Beim Übermitteln von Daten aber nicht unbedingt. Wenn man  z.B. Daten für eine Wetterstation sammeln will, dann ist es sinnvoll nur alle paar Minuten eine Messung zu machen, die dann an einen Rechner  übermittelt wird. In der Ruhephase kann man die Messmimik abschalten oder in eine stromsparende Ruhephase versetzen. Die Batterielaufzeit der  Messmimik erhöht sich dadurch enorm. Für den Fall muss dann der PC zum Server und das ESP8266D1 Board zum Client werden. Der PC wartet dann,  bis das Board sich bei ihm meldet. Das Board muss in dem Fall nicht dauerhaft mit dem WLAN verbunden sein. Die Methode werde ich auch noch  ausprobieren.  
Zuletzt geändert von asterix am 31.07.2018, 12:49, insgesamt 17-mal geändert.
Das ist meine persönliche Meinung dazu. Basierend auf einer nach bestem Wissen und Gewissen recherchierten Faktenlage.
Mike
Beiträge: 5
Registriert: 24.05.2018, 08:49

30.07.2018, 08:46

Moin.

Ich finde solche Hinweise zum Selbstbau toll - ich habe schon "Radioaktivität messen" mit großem Interesse gelesen.

Eine kleine Anmerkung hätte ich noch. Es gibt inzwischen Nachfolger zum ESP8266 mit viel mehr Speicher, u.a. ESP32-WROVER, mit CE Zertifizierung. Bei Mouser 3,57 Euro als Einzelstück, Evaluation Board mit 320x240 LCD 34,00 Euro. Kleine Platinen mit USB Anschluss und 2,54 mm Raster Steckern gibt es für 13 Euro bei Amazon.

Für mich ist der deswegen extrem interessant, weil auf dem auch MicroPython läuft - in der Version von loboris mit allem, was man sich wünscht: Telnet und ftp Server, Webserver, alle Peripherie unterstützt, LCD-Displays unterstützt, echtes Multitasking (wer Python kennt, weiß, was ich meine), deep sleep mode, etc. pp. Turnaround-Zeiten extrem klein - Textdatei editieren, per ftp übertragen, in Telnet oder COM Kommandozeile starten.

Der ESP32 hat 2 CPU Kerne, so dass WLAN oder Bluetooth "nebenbei" laufen. Der WROVER hat genug Speicher, um Firmware Update über WLAN zu unterstützen. Basis ist FreeRTOS, der ESP32 ist eine Referenzplattform dafür.
 
asterix
Beiträge: 109
Registriert: 23.05.2018, 08:24

30.07.2018, 12:24

Hallo Mike,

danke für das Feedback. Mir geht es hauptsächlich darum, Interessenten mit kleinem Geldbeutel zu mobilisieren. Der Chip selbst ist ziemlich kostengünstig zu haben. Ich habe gesehen, es gibt dafür auch Programmer für um die 20€ zu kaufen. Ein kleines Development Board werde ich mir auf alle Fälle einmal zum Ausprobieren bestellen. Ich habe gesehen, beim chinesischen Kollegen gibt es schon für um die 5,5€ ein Evaluations Board . Mit Python habe ich noch nicht gearbeitet. Ich bin sozusagen mit c aufgewachsen. Ich habe aber gesehen, es gibt auch Möglichkeiten Arduino-Boards mit Python zu programieren.. Vielleicht schreibt ja einmal jamand was in Richtung Pyton und Mikrocontroller.
Das ist meine persönliche Meinung dazu. Basierend auf einer nach bestem Wissen und Gewissen recherchierten Faktenlage.
asterix
Beiträge: 109
Registriert: 23.05.2018, 08:24

31.07.2018, 14:05

Jetzt der ESP als Client und der PC als Server.

ESP_Client__PC_Server.jpg
ESP_Client__PC_Server.jpg (151.34 KiB) 224 mal betrachtet

Die Hardware für den Client ist identisch mit der Hardware die für den Server benutzt wurde.
 
Board_Basis_Client.jpg
Board_Basis_Client.jpg (224.29 KiB) 224 mal betrachtet

Für den Client braucht man zuerst einmal die IP-Adresse des eigenen Rechners. Der soll ja etwas dort hin senden. Die ermittelt man am Einfachsten über ipconfig in der Eingabeaufforderung.

ipconfig.jpg
ipconfig.jpg (52.31 KiB) 224 mal betrachtet

Das Programm für das Board ist auch nicht sonderlich umfangreich.

Code: Alles auswählen

#include <ESP8266WiFi.h>

const char* pc_ip = "192.168.178.23"; // über ipconfig in der Eingabeaufforderung ermitteln
const int   pc_Port=80;
const char* ssid     = "Name des WLAN-Netzwerks"
";const char* password = "1234567890";


int rt_ledPin=D2;
int gr_ledPin=D1;
int ge_ledPin=D5;


void setup()
  {
  pinMode(gr_ledPin, OUTPUT);
  pinMode(rt_ledPin, OUTPUT);
  pinMode(ge_ledPin, OUTPUT);
  digitalWrite(rt_ledPin, HIGH);
  digitalWrite(gr_ledPin, LOW);
  delay(10);
  Serial.begin(9600);
  delay(10);

  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
 
  while (WiFi.status() != WL_CONNECTED)
    {
    delay(500);
    Serial.print(".");
    }
  digitalWrite(gr_ledPin, HIGH);
  digitalWrite(rt_ledPin, LOW);

  Serial.println("");
  Serial.println("WiFi connected");  
  Serial.print("ESP-Board IP Addresse: ");
  Serial.println(WiFi.localIP());
  }

int lnr=0;
void loop()
  {
  delay(1000);
  digitalWrite(ge_ledPin,HIGH);

  Serial.print("connecting to ");
  Serial.println(pc_ip);
 
  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(pc_ip,pc_Port))
    {
    Serial.println("connection failed");
    digitalWrite(ge_ledPin, LOW);
    return;
    }

  String s=String(++lnr)+" ...Daten vom Client\n\r";
  Serial.print("Sende Daten an PC: "+s);
  client.print(s);
  unsigned long timeout = millis();
  while (client.available() == 0)
    {
    if (millis() - timeout > 5000)
      {
      Serial.println(">>> Client Timeout !");
      client.stop();
      digitalWrite(ge_ledPin, LOW);
      return;
      }
    }
 
  Serial.print("Antwort vom PC: ");
  while(client.available())
    {
    String line = client.readStringUntil('\r');
    Serial.print(line);
    }
  digitalWrite(ge_ledPin, LOW);
 
  Serial.println("closing connection");
  Serial.println();
  Serial.println();
  } 

Im Programm muss zusätzlich zur IP des Zielrechners wieder der Name des verwendeten Netzwerks und das Passwort im Programm unter "ssid" und "password" eingetragen werden. Nach erfolgreichem Aufspielen sollte das Programm sich in das Netzwerk einwählen, was dann wieder über die grüne LED angezeigt wird.


Der PC-Server lässt sich auch relativ einfach realisieren.

Code: Alles auswählen

/*
getestet mit
mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0 in CodeBlocks
libws2_32.a müssen mit eingebunden werden.
Basis: http://www.willemer.de/informatik/unix/unprsock.htm
*/


using namespace std;

#include <iostream>
#include <ostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <winsock.h>


#define BUF_LEN 1024
#define PORT 80


void SocketError()
  {
  ::std::cerr << "Fatal Error" << '\n';
  WSACleanup();
  ::std::system( "PAUSE" );
  exit(0);
  }


int main()
    {
    WSADATA wsaData;
    int IDMySocket;
    if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
      SocketError();
    char Puffer[BUF_LEN];
    if((IDMySocket=socket(AF_INET, SOCK_STREAM, 0))==0)
      SocketError();
    struct sockaddr_in AdrMySock = { 0 };
    AdrMySock.sin_family = AF_INET;
    AdrMySock.sin_addr.s_addr = INADDR_ANY; // akzept. jeden
    AdrMySock.sin_port = htons(PORT);
    struct sockaddr_in AdrPartnerSocket;
    int AdrLen = sizeof(struct sockaddr);
    if(bind(IDMySocket, (sockaddr*)&AdrMySock, sizeof(AdrMySock)) < 0)
      SocketError();
    if(listen(IDMySocket, 5) < 0)
      SocketError();

    std::cout << "Starte Endlosabfrage: \n";
    for(;;)
      {
      // Das Casting auf (sockaddr*) ist bei Windows erforderlich
      int IDPartnerSocket = accept(IDMySocket, (sockaddr*)&AdrPartnerSocket, &AdrLen);
      if(*Puffer)
         memset (Puffer,0,BUF_LEN);     
      int MsgLen = recv(IDPartnerSocket,Puffer,BUF_LEN,0);
      if (MsgLen>0)
        {
        std::cout << Puffer << "\n";
        string daten(Puffer);
        string antwort="habe Daten gelesen ... "+daten+"\r";
        send(IDPartnerSocket,antwort.c_str(),strlen(antwort.c_str()), 0);
        }
      closesocket(IDPartnerSocket);
      }
    closesocket(IDMySocket);
    WSACleanup();
    ::std::system( "PAUSE" );
    }

Der Client sendet jede Sekunde eine um 1 erhöhte Zahl an den Server. Beim Sendevorgang leuchtet die gelbe LED kurz auf. Wenn alles funktioniert hat, dann sollte die PC-Ausgabe wie folgt aussehen:

pc_serverausgabe.jpg
pc_serverausgabe.jpg (57.75 KiB) 224 mal betrachtet
 

Solange das Board noch über das USB-Kabel mit dem Rechner verbunden ist, kann man über den seriellen Monitor mitverfolgen wie der PC antwortet.

 
ESP_clientausgabe.jpg
ESP_clientausgabe.jpg (115.98 KiB) 224 mal betrachtet

Für die bisherigen Methoden muss der heimische Router mitbenutzt werden. Interessant wäre dann noch eine Funkverbindung bei der nur zwei ESP benötigt werden. Das werde ich als nächstes einmal testen.

 
Das ist meine persönliche Meinung dazu. Basierend auf einer nach bestem Wissen und Gewissen recherchierten Faktenlage.
asterix
Beiträge: 109
Registriert: 23.05.2018, 08:24

02.08.2018, 13:38

Jetzt noch eine direkte Verbindung von zwei ESP.

ESP_Client_ESP_Server_direkt.jpg
ESP_Client_ESP_Server_direkt.jpg (114.4 KiB) 204 mal betrachtet

Die Boards werden wieder genau so beschaltet wie in den voran gegangenen Beispielen. Zuerst der Server.

Board_Basis_Server_DV.jpg
Board_Basis_Server_DV.jpg (224.29 KiB) 204 mal betrachtet

Bei der im ersten Post vorgestellten Methode ist im ESP-Sketch zuerst eine Verbindung zu einem fremden Router aufgebaut worden, an die dann der Server angehängt wurde. Nun ist es auch möglich den ESP zu einem etwas abgespeckten Router, einem Acces Point, zu machen und den Server dann dort anzuhängen. Wie der ESP zum Acces Point wird, ist hier beschrieben. Der Rest des Sketches ist identisch mit dem des ersten Beispiels. Die Beispiele sind übrigens alle in einer ähnlichen Form in den Beispielprogrammen zu der Arduino-IDE vorhanden. Der Server bekommt voreinstellungsmäßig die IP-Adresse 192.168.4.1 zugewiesen.

Code: Alles auswählen

/*
 Info: https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/soft-access-point-class.html
*/ 
#include <ESP8266WiFi.h>
#include <WiFiClient.h> 

const char *ssid = "ESP_8266_DV";
const char *password = "espdirektverbindung";

int rt_ledPin=D2;
int gr_ledPin=D1; 
int ge_ledPin=D5; 

WiFiServer server(80);

void setup()
  {
  pinMode(gr_ledPin, OUTPUT);
  pinMode(rt_ledPin, OUTPUT);
  pinMode(ge_ledPin, OUTPUT);
  digitalWrite(rt_ledPin, HIGH);
  digitalWrite(gr_ledPin, LOW);    
  Serial.begin(9600);
  Serial.println();
  Serial.print("Setting soft-AP configuration ... ");
  Serial.print("Setting soft-AP ... ");
  WiFi.mode(WIFI_AP);

  if(WiFi.softAP(ssid,password))
    {
    digitalWrite(gr_ledPin, HIGH);
    digitalWrite(rt_ledPin, LOW);
    Serial.println("Ready");
    }
  else  
    Serial.println("Failed!");
  Serial.print("Soft-AP IP address = ");
  Serial.println(WiFi.softAPIP());
  server.begin();
  }
void loop()
  {
  WiFiClient client;
  if (!(client = server.available())) // Client angemeldet?
    return;
  digitalWrite(ge_ledPin,HIGH);
  Serial.println("Client angemeldet");

  unsigned long time0= millis();
  while(!client.available())
    {
    if((millis()-time0) > 5000)// Verbindung abgebrochen;
      {
      digitalWrite(ge_ledPin, LOW);
      return;
      }
    delay(1);
    }
  String a = client.readStringUntil('\r');
  client.flush();
  String s="Antwort vom Server auf "+a+"\r";
  client.print(s);
  client.flush();
  delay(1);
  digitalWrite(ge_ledPin, LOW);
  }


SSID und Passwort können hier frei gewählt werden. Nach den Aufspielen des Sketch sieht man im seriellen Monitor die IP-Adresse mit der der Server angesprochen werden kann.

ip_direktverbindung.jpg
ip_direktverbindung.jpg (37.67 KiB) 204 mal betrachtet

Wenn ein Passwort verwendet wird, dann muss das lang genug sein. Beim Verwenden von z.B. "123" verweigert Windows eine eventuell gewünschte Verbindung. Wenn alles glatt gelaufen ist, sieht man den Soft Access Point bei eingestecktem WLAN-Stick im Verbindungsmonitor.

Verbindungsmonitor.jpg
Verbindungsmonitor.jpg (44.84 KiB) 204 mal betrachtet

Zur Verwendung des ESP-Clients ist diese Verbindung nicht notwendig. Aber bei erfolgreicher Verbindung sollte auch der Zugriff mit dem PC-Clientprogramm aus dem ersten Anwendungsbeispiel problemlos funktionieren. Dort muss nur die IP-Adresse 192.168.4.1 verwendet werden.


Jetzt der Client. Wieder die gleiche Beschaltung.

Board_Basis_Client_DV.jpg
Board_Basis_Client_DV.jpg (224.29 KiB) 204 mal betrachtet

Der Sketch ist identisch mit dem aus dem letzten Beispiel. Nur für die IP-Adresse muss jetzt die des Servers für die Direktverbindung verwendet werden. Die SSID und das Passwort muss ebenfalls angepasst werden.

Code: Alles auswählen

#include <ESP8266WiFi.h>

const char* ip = "192.168.4.1"; 
const int   pc_Port=80;

const char *ssid = "ESP_8266_DV";
const char *password = "espdirektverbindung";


int rt_ledPin=D2;
int gr_ledPin=D1; 
int ge_ledPin=D5; 


void setup() 
  {
  pinMode(gr_ledPin, OUTPUT);
  pinMode(rt_ledPin, OUTPUT);
  pinMode(ge_ledPin, OUTPUT);
  digitalWrite(rt_ledPin, HIGH);
  digitalWrite(gr_ledPin, LOW);
  delay(10);
  Serial.begin(9600);
  delay(10);

  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) 
    {
    delay(500);
    Serial.print(".");
    }
  digitalWrite(gr_ledPin, HIGH);
  digitalWrite(rt_ledPin, LOW);
  Serial.println("");
  Serial.println("WiFi connected");  
  Serial.print("ESP-Board IP Addresse: ");
  Serial.println(WiFi.localIP());
  }

int lnr=0;
void loop()
  {
  delay(1000);
  digitalWrite(ge_ledPin,HIGH);

  Serial.print("connecting to ");
  Serial.println(ip);
  
  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(ip,pc_Port)) 
    {
    Serial.println("connection failed");
    digitalWrite(ge_ledPin, LOW);
    return;
    }

  String s=String(++lnr)+" ...Daten vom Client\n\r";
  Serial.print("Sende Daten an Server am Acces Point: "+s);
  client.print(s);
  unsigned long timeout = millis();
  while (client.available() == 0) 
    {
    if (millis() - timeout > 5000) 
      {
      Serial.println(">>> Client Timeout !");
      client.stop();
      digitalWrite(ge_ledPin, LOW);
      return;
      }
    }
  
  Serial.print("Antwort vom Server: ");
  while(client.available())
    {
    String line = client.readStringUntil('\r');
    Serial.print(line);
    }
  digitalWrite(ge_ledPin, LOW);
  
  Serial.println("closing connection");
  Serial.println();
  Serial.println();
  }



Nach erfolgreichem Aufspielen sollte das Programm sich beim durch den ersten ESP realisierten Accses Point einwählen, was dann wieder über die grüne LED angezeigt wird.

Mit dem seriellen Monitor lässt sich die Kommunikation zwischen den beiden ESP mitverfolgen.

komm_direktverbindung.jpg
komm_direktverbindung.jpg (166.9 KiB) 204 mal betrachtet
Das ist meine persönliche Meinung dazu. Basierend auf einer nach bestem Wissen und Gewissen recherchierten Faktenlage.
Benutzeravatar
Rudi
Beiträge: 99
Registriert: 24.05.2018, 06:54

02.08.2018, 15:54

Das könnte auch für ein paar Anwendungen bei mir interessant sein. Ich bin mir nur nicht sicher, ob damit folgender Use-Case abgebildet werden kann, vielleicht kannst Du das beantworten:
1. Auf einem Windows-PC läuft ein Programm, was zu verscheidenen Zeiten an Aktoren einen Befehl versendet.
2. Wenn der Aktor den Befehl bekommt, wird eine Quittungsmeldung zurückgesendet
3. Außerdem wird z.B. ein Relais durch den Aktor für eine bestimmte Zeit angeschaltet.

Kann man so einen Aktor durch das beschriebene Board aufbauen (Wlan natürlich vorausgesetzt)?
asterix
Beiträge: 109
Registriert: 23.05.2018, 08:24

02.08.2018, 19:30

Es gibt da mehrere Möglichkeiten.

Die einzelnen Aktoren können jeweils an einem ESP-Server aus dem letzten Beispiel angebunden sein. Die sind dann schon einmal über unterschiedliche SSID einzeln ansprechbar. Zum Ansprechen kann man das PC-Clientprogramm aus dem ersten Beispiel benutzen. Man muss nur für jeden Aktor dann die entsprechende SSID benutzen.

Die einzelnen Aktoren können jeweils an einem über einen Router erreichbaren ESP-Server aus dem ersten Beispiel angebunden sein. Die sind dann über die SSID des heimischen Routers ansprechbar. Die IP-Adressen werden den Servern vom Router zugewiesen. Zum Ansprechen kann man auch das PC-Clientprogramm aus dem ersten Beispiel benutzen. Man muss hier nur für jeden Aktor die entsprechende IP-Adresse benutzen.

Wenn die Aktoren räumlich nicht getrennt sind, dann genügt auch ein einziger Server für alle Aktoren. Der Client kann dem Server ja mitteilen wer gemeint ist. Und wenn der Client sich z.B. mit Aktor1 im Text meldet, dann weiß der Server ja für wen die Aufgabe bestimmt ist.



 
Das ist meine persönliche Meinung dazu. Basierend auf einer nach bestem Wissen und Gewissen recherchierten Faktenlage.
Antworten
  • Information