ESP32 Połączenie z wifi

By /
Table Of Contents
  1. Połączenie z wifi, wyświetlenie adresu IP, MAC
  2. Skanowanie pobliskich sieci wifi
  3. Wysyłanie danych pomiędzy 2 płytkami ESP32
  4. Wysyłanie danych do wszystkich – broadcast
  5. Pobieranie czasu z internetu z biblioteką NTPClient by Fabrice Weinberg
  6. Sterowanie płytką przez wifi z serwera lokalnego
  7. Sterowanie ESP32 przez wifi z mDNS

Zobacz: ESP32 Pierwsze kroki

Połączenie z wifi, wyświetlenie adresu IP, MAC

#include <WiFi.h>
const char* ssid = "**";
const char* password = "**";

void setup() {
  Serial.begin(115200);
  connectToNetwork();
  displayWifiInfo();
}

void loop() {}

void connectToNetwork() {
  WiFi.begin(ssid, password);
  Serial.print("Establishing connection to WiFi.");
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }
  Serial.println("Connected ;)");
}

void displayWifiInfo(){
  Serial.print("Network name: ");
  Serial.println(WiFi.SSID());
  Serial.print("Signal strength: ");
  Serial.println(WiFi.RSSI());
  Serial.print("MAC Address [router]: ");
  Serial.println(WiFi.BSSIDstr());  
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());
  Serial.print("MAC Address [device]: ");
  Serial.println(WiFi.macAddress());
}

Skanowanie pobliskich sieci wifi

#include <WiFi.h>

const char* ssid = "matineo24";             
const char* password = "bge9wfl3gwts8egu"; 

String translateEncryptionType(wifi_auth_mode_t encryptionType) {
  switch (encryptionType) {
    case (WIFI_AUTH_OPEN):
      return "Open";
    case (WIFI_AUTH_WEP):
      return "WEP";
    case (WIFI_AUTH_WPA_PSK):
      return "WPA_PSK";
    case (WIFI_AUTH_WPA2_PSK):
      return "WPA2_PSK";
    case (WIFI_AUTH_WPA_WPA2_PSK):
      return "WPA_WPA2_PSK";
    case (WIFI_AUTH_WPA2_ENTERPRISE):
      return "WPA2_ENTERPRISE";
  }
}

void scanNetworks() {
  int numberOfNetworks = WiFi.scanNetworks();
  Serial.print("Number of networks found: ");
  Serial.println(numberOfNetworks);

  for (int i = 0; i < numberOfNetworks; i++) {
    Serial.print("Network name: ");
    Serial.println(WiFi.SSID(i));
    Serial.print("Signal strength: ");
    Serial.println(WiFi.RSSI(i));
    Serial.print("MAC address: ");
    Serial.println(WiFi.BSSIDstr(i)); 
    Serial.print("Encryption type: ");
    String encryptionTypeDescription = translateEncryptionType(WiFi.encryptionType(i));
    Serial.println(encryptionTypeDescription);
    Serial.println("-----------------------");
  }
}

void setup() {
  Serial.begin(115200);
  scanNetworks();
}

void loop() {}

Wysyłanie danych pomiędzy 2 płytkami ESP32

// receiver
#include <WiFi.h>
const char* ssid = "*";
const char* password = "*";

#include <WiFiUdp.h>

WiFiUDP udp;
const int udpPort = 1234;
char packetBuffer[255];

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }

  Serial.println("\nConnected!");
  Serial.print("Local IP: ");
  Serial.println(WiFi.localIP());

  udp.begin(udpPort);
}

void loop() {
  int packetSize = udp.parsePacket();
  if (packetSize) {
    int len = udp.read(packetBuffer, 255);
    if (len > 0) {
      packetBuffer[len] = '\0';
    }

    Serial.print("Received: ");
    Serial.println(packetBuffer);
  }

  delay(100);
}


//sender
#include <WiFi.h>

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

#include <WiFiUdp.h>

WiFiUDP udp;
const char* serverIP = "192.168.0.45";  // IP serwera UDP (ESP32)
const int udpPort = 1234;

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }

  Serial.println("\nConnected!");
}

void loop() {
  Serial.println("Sending UDP message...");
  
  udp.beginPacket(serverIP, udpPort);
  udp.print("Hello from ESP32!");
  udp.endPacket();

  delay(2000);
}

Wysyłanie danych do wszystkich – broadcast

#include <conn.h>
#include <WiFi.h>
#include <WiFiUdp.h>
// const char* ssid = "";
// const char* password = "";

WiFiUDP udp;
const int udpPort = 1234;  // Ten sam port, na którym serwer nasłuchuje
const char* broadcastIP = "192.168.0.255";  // Broadcast dla sieci 192.168.0.X

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }

  Serial.println("\nConnected to WiFi!");
  udp.begin(udpPort);  // Rozpocznij nasłuchiwanie na tym porcie
}

void loop() {
  Serial.println("Sending UDP message to broadcast...");

  udp.beginPacket(broadcastIP, udpPort);  // Wysłać do broadcastu
  udp.print("Hello from ESP32 (broadcast)!");
  udp.endPacket();  // Zakończ wysyłanie pakietu

  delay(2000);  // Wysyłaj co 2 sekundy
}

Pobieranie czasu z internetu z biblioteką NTPClient by Fabrice Weinberg

#include <WiFi.h>

const char* ssid = "*";
const char* password = "*";
#include <NTPClient.h>
#include <WiFiUdp.h>
#define UTC_OFFSET_IN_SECONDS 3600  // UTC+1 (dla Polski)

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", UTC_OFFSET_IN_SECONDS);

void setup() {
  Serial.begin(115200);
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("\nConnected!");
  timeClient.begin();
  timeClient.update();
}

void loop() {
  timeClient.update();

  Serial.print("Aktualny czas: ");
  Serial.println(getTimeStampString());

  delay(1000);
}

String getTimeStampString() {
  time_t rawtime = timeClient.getEpochTime();
  struct tm * ti;
  ti = localtime(&rawtime);

  char buffer[20];
  strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ti);
  return String(buffer);
}

Sterowanie płytką przez wifi z serwera lokalnego

#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "**";
const char* password = "**";
const int LED_PIN = 8;
WebServer server(80);
bool ledState = false;

const char htmlPage[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <title>ESP32 Web Server</title>
  <style>
    body { font-family: Arial, sans-serif; text-align: center; }
    button { padding: 10px 24px; font-size: 1rem; }
  </style>
</head>
<body>
  <h1>ESP32 Web Server</h1>
  <p><button onclick="toggleLED()">Toggle LED</button></p>
  <p id="status">LED is OFF</p>
  <script>
    function toggleLED() {
      fetch('/toggle').then(res => res.text()).then(state => 
        document.getElementById('status').innerText = 'LED is ' + state);
    }
  </script>
</body>
</html>
)rawliteral";

void handleRoot() {
  server.send(200, "text/html", htmlPage);
}

void handleToggle() {
  ledState = !ledState;
  digitalWrite(LED_PIN, ledState ? HIGH : LOW);
  server.send(200, "text/plain", ledState ? "ON" : "OFF");
}

void connectWiFi() {

  Serial.print("Connecting...");
  WiFi.begin(ssid, password);
  unsigned long startAttemptTime = millis();

  while (WiFi.status() != WL_CONNECTED && millis() - startAttemptTime < 15000) {
    delay(500);
    Serial.print(".");
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWiFi connected. IP: " + WiFi.localIP().toString());
  } else {
    Serial.println("\nNot connected");
  }
}

void setup() {
  delay(1000);
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);

  connectWiFi();

  server.on("/", handleRoot);
  server.on("/toggle", handleToggle);
  server.begin();
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Restoring connection...");
    connectWiFi();
  }
  server.handleClient();
}

Sterowanie ESP32 przez wifi z mDNS

Poniższy kod zamienia adres IP na podaną nazwę, np: http://led

#include <WiFi.h>
#include <WebServer.h>
#include <ESPmDNS.h> 

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


WebServer server(80);
const int ledPin = 8;
bool ledState = false;

const char htmlPage[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <title>ESP32 Web Server</title>
  <style>
    body { font-family: Arial, sans-serif; text-align: center; }
    button { padding: 10px 24px; font-size: 1rem; }
  </style>
</head>
<body>
  <h1>ESP32 Web Server</h1>
  <p><button onclick="toggleLED()">Toggle LED</button></p>
  <p id="status">LED is OFF</p>
  <script>
    function toggleLED() {
      fetch('/toggle').then(res => res.text()).then(state => 
        document.getElementById('status').innerText = 'LED is ' + state);
    }
  </script>
</body>
</html>
)rawliteral";

void handleRoot() { server.send(200, "text/html", htmlPage); }

void handleToggle() {
  ledState = !ledState;
  digitalWrite(ledPin, ledState);
  server.send(200, "text/plain", !ledState ? "ON" : "OFF");
}

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  Serial.println("\nWiFi connected. IP: " + WiFi.localIP().toString());

  // Konfiguracja mDNS, umożliwia dostęp do ESP32 jako http://led.local
  if (MDNS.begin("led")) {  
    Serial.println("mDNS responder started. Access at http://led");
  } else {
    Serial.println("Error setting up mDNS!");
  }

  server.on("/", handleRoot);
  server.on("/toggle", handleToggle);
  server.begin();
}

void loop() { server.handleClient(); }

Related Posts

Leave a Comment

Scroll to Top