Informationen zum Code

NodeMCU (ESP8266) - OLED Display Anschlussanleitung

Vorteile des NodeMCU (ESP8266)

Der NodeMCU bietet gegenüber einem Standard-Arduino einige entscheidende Vorteile für Projekte mit Displays:

• Integriertes WLAN - IoT-Projekte ohne zusätzliche Module möglich
• Höhere Taktrate - mit 80/160 MHz deutlich schneller als Arduino (16 MHz)
• Mehr Speicher - bis zu 4MB Flash-Speicher für komplexere Grafiken
• 3.3V Logik - direkt kompatibel mit den meisten OLED-Displays (ohne Pegelwandler)
• Kompaktere Bauform - ideal für platzsparende Projekte

Pinbelegung

Der Anschluss eines I2C OLED-Displays an einen NodeMCU ist dank des I2C-Bus sehr einfach:

Benötigte Bibliotheken

Für die Verwendung eines OLED-Displays mit dem NodeMCU benötigst du folgende Bibliotheken:

• Adafruit SSD1306: Für die Steuerung des OLED-Displays
• Adafruit GFX Library: Für die Grafikfunktionen
• ESP8266WiFi: Für die grundlegende ESP8266-Funktionalität (bereits in der ESP8266-Boardinstallation enthalten)
• Wire.h: Für die I2C-Kommunikation (standardmäßig enthalten)

Installation der Bibliotheken und Board-Unterstützung

Bevor du mit dem NodeMCU arbeiten kannst, musst du die Board-Unterstützung und benötigten Bibliotheken installieren:

1. Öffne die Arduino IDE
2. Navigiere zu Datei > Voreinstellungen
3. Füge folgende URL zu den "Zusätzliche Boardverwalter-URLs" hinzu:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

4. Bestätige mit OK
5. Navigiere zu Werkzeuge > Board > Boardverwalter
6. Suche nach "esp8266" und installiere "ESP8266 by ESP8266 Community"
7. Navigiere zu Werkzeuge > Bibliotheken verwalten
8. Suche nach "Adafruit SSD1306" und installiere diese Bibliothek
9. Suche nach "Adafruit GFX" und installiere diese Bibliothek

Board-Auswahl in der Arduino IDE

Nachdem du die ESP8266-Boardunterstützung installiert hast:

1. Navigiere zu Werkzeuge > Board
2. Wähle "NodeMCU 1.0 (ESP-12E Module)" aus der Liste

Stelle außerdem diese weiteren Einstellungen ein:

• Flash Size: "4MB (FS:1MB OTA:~1019KB)"
• CPU Frequency: "80 MHz" (für die meisten Anwendungen ausreichend)
• Upload Speed: "115200" (kann je nach Verbindung angepasst werden)

I2C-Adresse

Die Standard-I2C-Adresse des Displays ist 0x3C. Falls dein Display nicht erkannt wird, versuche 0x3D als alternative Adresse.

Verwende diesen I2C-Scanner, um die korrekte Adresse deines Displays zu ermitteln:

#include 

void setup() {
  Wire.begin(D2, D1); // SDA=D2, SCL=D1 beim NodeMCU
  Serial.begin(115200);
  delay(1000); // Warten auf Stabilisierung der seriellen Verbindung
  Serial.println("\nI2C Scanner für NodeMCU");
}

void loop() {
  byte error, address;
  int deviceCount = 0;
  
  Serial.println("Scanning...");
  
  for(address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    
    if (error == 0) {
      Serial.print("I2C-Gerät gefunden an Adresse 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
      deviceCount++;
    }
  }
  
  if (deviceCount == 0) {
    Serial.println("Keine I2C-Geräte gefunden!\n");
  } else {
    Serial.println("Scan abgeschlossen!\n");
  }
  
  delay(5000); // Warte 5 Sekunden, dann scanne erneut
}

Übertragungsgeschwindigkeit

Stelle die serielle Übertragungsgeschwindigkeit auf 115200 Baud ein für optimale Leistung. Dies ist wichtig für eine schnelle Kommunikation mit dem ESP8266:

void setup() {
  Serial.begin(115200);
  // Rest des setup()-Codes
}

Erste Schritte mit dem NodeMCU und OLED

Hier ist ein Beispiel-Code, der ein OLED-Display initialisiert und einen einfachen Text anzeigt:

#include 
#include 
#include 
#include 

// Display-Konfiguration
#define SCREEN_WIDTH 128    // OLED-Display-Breite in Pixeln
#define SCREEN_HEIGHT 64    // OLED-Display-Höhe in Pixeln
#define OLED_RESET -1       // Reset Pin (-1 = teilt Reset Pin des ESP8266)
#define SCREEN_ADDRESS 0x3C // oder 0x3D für manche Displays

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  Serial.begin(115200);
  
  // Standard-Pins für den NodeMCU sind D1(SCL) und D2(SDA)
  Wire.begin(D2, D1); // SDA=D2, SCL=D1
  
  // SSD1306 Display initialisieren
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 Initialisierung fehlgeschlagen"));
    for(;;); // Programm anhalten, wenn Display nicht gefunden wurde
  }

  // Display leeren und Grundeinstellungen
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  
  // Beispieltext anzeigen
  display.println(F("NodeMCU + OLED Test"));
  display.println(F("Es funktioniert!"));
  display.println();
  display.print(F("ESP8266 Chip ID: "));
  display.println(ESP.getChipId(), HEX);
  display.print(F("Flash Size: "));
  display.print(ESP.getFlashChipSize() / 1024 / 1024);
  display.println(F(" MB"));
  
  // Änderungen anzeigen
  display.display();
}

void loop() {
  // Hier kommt dein Hauptcode hin
}

Alternative Pinbelegung

Falls du andere Pins verwenden möchtest, kannst du die I2C-Pins im Code umkonfigurieren:

// Am Anfang des Sketches
#define SDA_PIN 4  // D2 auf NodeMCU
#define SCL_PIN 5  // D1 auf NodeMCU

// In setup() vor display.begin()
Wire.begin(SDA_PIN, SCL_PIN);

Die GPIO-Nummern und NodeMCU-Pin-Bezeichnungen können verwirrend sein. Hier ist eine Übersicht wichtiger Pins:

* Diese Pins haben beim Booten spezielle Funktionen und können daher in manchen Fällen problematisch sein.

WLAN-Funktionalität mit dem Display

Eine der größten Stärken des NodeMCU ist die integrierte WLAN-Funktionalität. Hier ist ein Beispiel, das WLAN-Informationen auf dem Display anzeigt:

#include 
#include 
#include 
#include 

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// WLAN-Zugangsdaten
const char* ssid = "Dein_WLAN_Name";
const char* password = "Dein_WLAN_Passwort";

void setup() {
  Serial.begin(115200);
  
  // Display initialisieren
  Wire.begin(D2, D1);
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 Initialisierung fehlgeschlagen"));
    for(;;);
  }
  display.clearDisplay();
  
  // Verbindungsstatus anzeigen
  displayWiFiConnecting();
  
  // Mit WLAN verbinden
  WiFi.begin(ssid, password);
  
  // Auf Verbindung warten und dabei den Status anzeigen
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    displayWiFiProgress();
  }
  
  // Verbunden - Infos anzeigen
  displayWiFiConnected();
}

void loop() {
  // WLAN-Status alle 10 Sekunden aktualisieren
  static unsigned long lastUpdate = 0;
  if (millis() - lastUpdate > 10000) {
    lastUpdate = millis();
    displayWiFiConnected();
  }
}

void displayWiFiConnecting() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(F("Verbinde mit WLAN:"));
  display.println(ssid);
  display.println();
  display.println(F("Bitte warten..."));
  display.display();
}

void displayWiFiProgress() {
  static int dots = 0;
  display.fillRect(0, 32, 128, 8, SSD1306_BLACK);
  display.setCursor(0, 32);
  display.print(F("Verbinde"));
  for (int i = 0; i < dots; i++) {
    display.print(".");
  }
  dots = (dots + 1) % 6;
  display.display();
}

void displayWiFiConnected() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(F("WLAN verbunden!"));
  display.println();
  display.print(F("SSID: "));
  display.println(WiFi.SSID());
  display.print(F("IP: "));
  display.println(WiFi.localIP());
  display.print(F("Signal: "));
  display.print(WiFi.RSSI());
  display.println(F(" dBm"));
  display.println();
  display.print(F("MAC: "));
  display.println(WiFi.macAddress());
  display.display();
}

Energiespartipps

Der ESP8266 hat einen relativ hohen Stromverbrauch. Für batteriebetriebene Projekte könntest du Deep-Sleep-Funktionen implementieren:

// Tiefschlaf für 5 Minuten (in Mikrosekunden)
ESP.deepSleep(300e6); // 300 Sekunden = 5 Minuten

Hier ist ein vollständiges Beispiel für einen energieeffizienten Betrieb mit Deep-Sleep:

#include 
#include 
#include 
#include 

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Zeit zwischen Messungen in Sekunden
const int sleepTime = 60; // 1 Minute

void setup() {
  Serial.begin(115200);
  Serial.println("ESP8266 aufgewacht!");
  
  // Display initialisieren
  Wire.begin(D2, D1);
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 Initialisierung fehlgeschlagen"));
    for(;;);
  }
  
  // Display-Helligkeit reduzieren (0-255)
  display.ssd1306_command(SSD1306_SETCONTRAST);
  display.ssd1306_command(10); // sehr niedrige Helligkeit
  
  // Bildschirm löschen
  display.clearDisplay();
  
  // Beispieldaten anzeigen
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(F("Batterie-Test"));
  
  // Aufwachanzahl aus RTC-Speicher lesen (bleibt im Tiefschlaf erhalten)
  ESP.rtcUserMemoryRead(0, &count, sizeof(count));
  count++;
  ESP.rtcUserMemoryWrite(0, &count, sizeof(count));
  
  display.print(F("Aufwachzyklus: "));
  display.println(count);
  
  // Aktuelle Betriebszeit anzeigen
  display.print(F("Betriebszeit: "));
  display.print(millis());
  display.println(F(" ms"));
  
  // Batteriespannung messen (falls angeschlossen)
  float voltage = readBatteryVoltage();
  display.print(F("Batterie: "));
  display.print(voltage);
  display.println(F(" V"));
  
  // In den nächsten Tiefschlaf Countdown
  display.println();
  display.print(F("Nächster Schlaf: "));
  display.print(sleepTime);
  display.println(F(" Sek."));
  
  display.display();
  
  // Display für 5 Sekunden anzeigen, dann ausschalten
  delay(5000);
  display.clearDisplay();
  display.display();
  
  // In den Tiefschlaf gehen
  Serial.println("Gehe in Tiefschlaf für " + String(sleepTime) + " Sekunden...");
  ESP.deepSleep(sleepTime * 1000000);
}

void loop() {
  // Wird nie erreicht wegen deepSleep im setup()
}

// Batteriespannung messen (A0 über Spannungsteiler angeschlossen)
float readBatteryVoltage() {
  // Annahme: A0 ist über 100k/220k Spannungsteiler angeschlossen
  // für 4.2V (volle Batterie) → ~1.3V am A0-Eingang
  float rawValue = analogRead(A0);
  float voltage = rawValue * 4.2 / 1024;
  return voltage;
}

Fehlerbehebung

Hier sind einige häufige Probleme und deren Lösungen für den NodeMCU mit OLED-Display:

• Display bleibt leer: Überprüfe die Verkabelung und die I2C-Adresse. Verwende den I2C-Scanner.
• Fehler "Board not found": Überprüfe, ob du den richtigen Treiber für den USB-Chip deines NodeMCU installiert hast (CH340 oder CP2102).
• Instabile Verbindung: Verwende ein hochwertiges USB-Kabel. Die billigen, dünnen Kabel können Probleme verursachen.
• Display zeigt nur Müll/Artefakte: Überprüfe die Stromversorgung. Der NodeMCU benötigt einen stabilen 5V-Eingang über USB.
• Out of Memory Fehler: Der ESP8266 hat begrenzten RAM. Vermeide große Arrays oder Strings und verwende F()-Makros für statische Strings.
• Reset-Schleifen: Der Watchdog Timer kann den ESP8266 zurücksetzen, wenn dein Code zu lange ohne yield() oder delay() ausführt.

Wemos D1 Mini als Alternative

Der Wemos D1 Mini ist eine noch kompaktere Alternative zum NodeMCU, die auf dem gleichen ESP8266-Chip basiert:

• Kleiner Formfaktor (34.2mm x 25.6mm)
• Gleiche Funktionalität wie NodeMCU
• Weniger Pins verfügbar, aber ausreichend für die meisten Projekte
• Sehr günstig und ideal für permanente Installationen

Die Pinbelegung für das OLED-Display ist beim D1 Mini identisch:

• D1 = SCL (GPIO 5)
• D2 = SDA (GPIO 4)

Projektideen mit NodeMCU und OLED

Der NodeMCU mit einem OLED-Display eignet sich hervorragend für folgende Projekte:

• WiFi-Scanner - Zeigt verfügbare WLAN-Netzwerke und deren Signalstärke an
• IoT-Wetterstations-Display - Zeigt Wetterdaten von Online-APIs an
• Smart Home Controller - Steuerung und Statusanzeige für MQTT-basierte Smart Home Geräte
• Netzwerk-Monitor - Überwacht Netzwerkverbindungen und zeigt Ping-Zeiten an
• Ferngesteuertes Display - Zeigt Nachrichten an, die über WLAN gesendet werden
• Batteriebetriebener Umgebungssensor - Misst und zeigt Temperatur, Luftfeuchtigkeit und Luftdruck an

Der ESP8266 in Kombination mit einem OLED-Display eröffnet eine Vielzahl von IoT-Möglichkeiten, die mit einem herkömmlichen Arduino so nicht möglich wären. Die WLAN-Fähigkeit macht ihn zur idealen Plattform für vernetzte Anzeigen und Sensor-Dashboards.