Stromversorgung mittels P-MOSFET / Anschluss TFT-Display an NodeMCU

Dann doch eben so :wink:

Nee, weiß halt echt nicht woran es liegen könnte.

// ---------- ERSTELLUNG MENÜ-ÜBERSICHT ---------- //

// BIBLIOTHEKEN
#include <SPI.h>                    // Bilbiothek für SPI-Schnittstelle
#include <TFT_eSPI.h>               // Bibliothek für TFT-Display (ohne Touch)
#include <XPT2046_Touchscreen.h>    // Bibliothek für Touchfunktion
#include <Math.h>                   // Bilbiothek für Mathematik
#include <EEPROM.h>                 // EEPROM-Bibliothek
#include <ESP8266WiFi.h>            // Bibliothek für WiFi-Verbindung
#include <ESP8266HTTPClient.h>      // Bibliothek für HTTP GET

// SCHRIFTARTEN
#include <Fonts\Custom\DialogBold8pt.h>         // Einfügen der Schriftart 8 pt
#include <Fonts\Custom\DialogBold12pt.h>        // Einfügen der Schriftart 12 pt
#include <Fonts\Custom\DialogBold13pt.h>        // Einfügen der Schriftart 13 pt

// GLOBALE KONSTANTEN
#define TFT_CS 15                 // GPIO Nummer für CS-Pin
#define TFT_TOUCH_CS 5            // GPIO Nummer für Touch_CS-Pin
#define ESP_ON 4                 // GPIO NUmmer für ESP_ON

// GLOBALE VARIABLEN
int i_mainpage = 0;               // Mainpage aufrufen
int i_socketpage = 0;             // Steckdosenpage aufrufen
int i_sensorpage = 0;             // Sensorpage aufrufen
int httpCode;                     // Integervariable für Status-Codes
boolean b_mainpage = false;       // Mainpage laden
boolean b_socketpage = false;     // Steckdosenpage laden
boolean b_sensorpage = false;     // Sensorpage laden
float m_x = 0.00f, m_y = 0.00f;   // für Kalibrierung
float n_xP = 0.00f, n_yP = 0.00f; // für Kalibrierung
char f_SD01[20], f_SD02[20];      // char-Arrays für Fehlermeldungen
char f_DHT11[20], t_DHT11[60];    // char-Arrays für DHT11 Meldungen

// FARBEN
#define BLUE1 0x2F5D              // Hintergrundfarbe
#define BLUE2 0x265C              // Farbe für AN / AUS Schalter
#define GREY1 0x29C7              // Textfarbe

// INITIALISIERUNG TFT-DISPLAY
TFT_eSPI tft = TFT_eSPI();

// INITIALISIERUNG TOUCHFUNKTION
XPT2046_Touchscreen ts(TFT_TOUCH_CS);

// INITIALISIERUNG CLIENT ZUR VERBINDUNG MIT SERVER
WiFiClient wificlient;

// WIFI ZUGANGSDATEN
const char* ssid = "Nicht verbunden";   // WLAN-Name als Pointer
const char* password = "c4r4&b4st1";    // WLAN-Passwort als Pointer


// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// KLASSEN
class ScreenPoint
{
  public:
    int16_t x;                      // Variable zum speichern
    int16_t y;                      // Variable zum Speichern

    ScreenPoint()                   // Konstuktor
    {
    }

    ScreenPoint(int16_t xIn, int16_t yIn)   // Methode
    {
      x = xIn;                              // Variable
      y = yIn;                              // Variable
    }
};


// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// BERECHNUNG DER PIXELKOORDINATEN
ScreenPoint getScreenPixel(int16_t x, int16_t y)      // Objekt erstellen
{
  int16_t xPixel = round((x * m_x) + n_xP);           // x-Pixelkoordinate berechnen
  int16_t yPixel = round((y * m_y) + n_yP);           // y-Pixelkoordinate berechnen
  if (xPixel < 0) xPixel = 0;                         // Pixelbereichszuweisung
  if (xPixel > tft.width()) xPixel = tft.width();     // Pixelbereichszuweisung
  if (yPixel < 0) yPixel = 0;                         // Pixelbereichszuweisung
  if (yPixel > tft.height()) yPixel = tft.height();   // Pixelbereichszuweisung
  return (ScreenPoint(xPixel, yPixel));               // Rückgabe der Pixelwerte
}


// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// FUNKTION GET REQUEST()
String GET_REQUEST(String request)
{
  HTTPClient http;                                // Instanz für ESP8266HTTPClient.h Bibliothek
  http.begin(wificlient, request);                // Beginn Verbindung zur Webseite
  httpCode = http.GET();                          // Anfrage an Server senden und Status-Code erhalten

  if ((httpCode >= 200) && (httpCode < 300))      // if-Abfrage Status-Code
  {
    return http.getString();                      // String zurückgeben
  } // if ((httpCode >= 200) && (httpCode < 300))

  else
  {
    return "0";                                   // String zurückgeben
  } // else

  http.end();                                     // Serveranfrage schließen
} // String GET_REQUEST()


// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// FUNKTION TEXT_WITH_FRAME()
void text_with_frame(int x, int y, const GFXfont* font, uint16_t textcolor, String text, boolean frame, int dx, int dy, int dw, int dh, int r, uint16_t framecolor)  // Parameter
{
  tft.setCursor(x, y);            // Cursor platzieren
  tft.setFreeFont(font);          // Schriftart einstellen
  tft.setTextColor(textcolor);    // Schriftfarbe einstellen
  tft.print(text);                // Textausgabe

  if (frame)
  {
    tft.drawRoundRect(dx, dy, dw, dh, r, framecolor);   // Textumrandung (optional)
  } // if(frame)
} // void text_with_frame()


// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// FUNKTION READEEPROM()
float readEEPROM(int adress)          // Übergabe der Parameter
{
  byte bytes[3];                      // Byte Array für 4 Bytes

  for (int i = 0; i <= 3; i++)        // Schleifenzähler bis 4 Bytes
  {
    bytes[i] = EEPROM.read(adress + i); // Lesen der Bytes aus EEPROM
  }

  float f = *(float*)bytes;           // Umwandlung in Floatzahl
  return f;                           // Rückgabe der Floatzahl
} // float readEEPROM()


// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// FUNKTION MAINPAGE()
void mainpage()
{
  // HINTERGRUNDFARBE
  tft.fillScreen(BLUE1);                    // Seitenhintergrundfarbe

  // ÜBERSCHRIFT "WLAN-FERNBEDIENUNG"
  text_with_frame(25, 35, &DialogBold13pt, GREY1, "WLAN-FERNBEDIENUNG", false, 0, 0, 0, 0, 0, 0);     // Übergabe an Funktion (Überschrift)
  tft.drawLine(30, 40, 210, 40, GREY1);     // Text unterstreichen

  // ÜBERSCHRIFTEN UNTERMENÜ's
  text_with_frame(70, 93, &DialogBold12pt, GREY1, "STECKDOSEN", true, 45, 75, 150, 28, 5, GREY1);     // Übergabe an Funktion - Textfeld (socketpage)
  text_with_frame(80, 143, &DialogBold12pt, GREY1, "SENSOREN", true, 45, 125, 150, 28, 5, GREY1);     // Übergabe an Funktion - Textfeld (sensorpage)
  text_with_frame(68, 193, &DialogBold12pt, GREY1, "NICHT BELEGT", true, 45, 175, 150, 28, 5, GREY1); // Übergabe an Funktion (n.c.)
  text_with_frame(68, 243, &DialogBold12pt, GREY1, "NICHT BELEGT", true, 45, 225, 150, 28, 5, GREY1); // Übergabe an Funktion (n.c.)
} // void mainpage()

// ------------------------------ //
// FUNKTION SOCKETPAGE()
void socketpage()
{
  // HINTERGRUNDFARBE
  tft.fillScreen(BLUE1);                     // Seitenhintergrundfarbe

  // ÜBERSCHRIFT "STECKDOSEN"
  text_with_frame(67, 35, &DialogBold13pt, GREY1, "STECKDOSEN", false, 0, 0, 0, 0, 0, 0);              // Übergabe an Funktion (Überschrift)
  tft.drawLine(70, 40, 170, 40, GREY1);     // Text unterstreichen

  // EINZELNE STECKDOSEN
  text_with_frame(20, 78, &DialogBold12pt, GREY1, "SD 01",  true, 10, 60, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(137, 78, &DialogBold12pt, GREY1, "AN",  true, 122, 60, 50, 28, 5, GREY1);            // Übergabe an Funktion (AN-Feld)
  text_with_frame(190, 78, &DialogBold12pt, GREY1, "AUS",  true, 180, 60, 50, 28, 5, GREY1);           // Übergabe an Funktion (AUS-Feld)

  text_with_frame(20, 113, &DialogBold12pt, GREY1, "SD 02", true, 10, 95, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(137, 113, &DialogBold12pt, GREY1, "AN",  true, 122, 95, 50, 28, 5, GREY1);           // Übergabe an Funktion (AN-Feld)
  text_with_frame(190, 113, &DialogBold12pt, GREY1, "AUS",  true, 180, 95, 50, 28, 5, GREY1);          // Übergabe an Funktion (AUS-Feld)

  text_with_frame(20, 148, &DialogBold12pt, GREY1, "N.C.", true, 10, 130, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(137, 148, &DialogBold12pt, GREY1, "AN",  true, 122, 130, 50, 28, 5, GREY1);          // Übergabe an Funktion (AN-Feld)
  text_with_frame(190, 148, &DialogBold12pt, GREY1, "AUS",  true, 180, 130, 50, 28, 5, GREY1);         // Übergabe an Funktion (AUS-Feld)

  text_with_frame(20, 183, &DialogBold12pt, GREY1, "N.C.", true, 10, 165, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(137, 183, &DialogBold12pt, GREY1, "AN",  true, 122, 165, 50, 28, 5, GREY1);          // Übergabe an Funktion (AN-Feld)
  text_with_frame(190, 183, &DialogBold12pt, GREY1, "AUS",  true, 180, 165, 50, 28, 5, GREY1);         // Übergabe an Funktion (AUS-Feld)

  text_with_frame(20, 218, &DialogBold12pt, GREY1, "N.C.", true, 10, 200, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(137, 218, &DialogBold12pt, GREY1, "AN",  true, 122, 200, 50, 28, 5, GREY1);          // Übergabe an Funktion (AN-Feld)
  text_with_frame(190, 218, &DialogBold12pt, GREY1, "AUS",  true, 180, 200, 50, 28, 5, GREY1);         // Übergabe an Funktion (AUS-Feld)

  // FEHLERCODEANZEIGE
  text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)

  // ZURÜCK ZUR MAINPAGE
  text_with_frame(18, 278, &DialogBold8pt, GREY1, "MAIN", true, 10, 265, 45, 20, 5, GREY1);            // Übergabe an Funktion (Zurück zur Mainpage)
} // void socketpage()

// ------------------------------ //
// FUNKTION SENSORPAGE()
void sensorpage()
{
  // HINTERGRUNDFARBE
  tft.fillScreen(BLUE1);                    // Seitenhintergrundfarbe

  // ÜBERSCHRIFT "SENSOREN"
  text_with_frame(75, 35, &DialogBold13pt, GREY1, "SENSOREN", false, 0, 0, 0, 0, 0, 0);                 // Übergabe an Funktion (Überschrift)
  tft.drawLine(80, 40, 155, 40, GREY1);     // Text unterstreichen

  // EINZELNE SENSOREN
  text_with_frame(20, 78, &DialogBold12pt, GREY1, "DHT11",  true, 10, 60, 100, 28, 5, GREY1);           // Übergabe an Funktion (Schriftfeld)
  text_with_frame(123, 78, &DialogBold12pt, GREY1, "M", true, 115, 60, 28, 28, 5, GREY1);               // Übergabe an Funktion (Messung)
  text_with_frame(20, 106, &DialogBold8pt, GREY1, "Messwerte: ", true, 10, 93, 220, 20, 5, GREY1);      // Übergabe an Funktion (Messwerte)

  text_with_frame(20, 141, &DialogBold12pt, GREY1, "N.C.",  true, 10, 123, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(123, 141, &DialogBold12pt, GREY1, "M", true, 115, 123, 28, 28, 5, GREY1);             // Übergabe an Funktion (Messung)
  text_with_frame(20, 169, &DialogBold8pt, GREY1, "Messwerte: ", true, 10, 156, 220, 20, 5, GREY1);     // Übergabe an Funktion (Messwerte)

  text_with_frame(20, 204, &DialogBold12pt, GREY1, "N.C.",  true, 10, 186, 100, 28, 5, GREY1);          // Übergabe an Funktion (Schriftfeld)
  text_with_frame(123, 204, &DialogBold12pt, GREY1, "M", true, 115, 186, 28, 28, 5, GREY1);             // Übergabe an Funktion (Messung)
  text_with_frame(20, 232, &DialogBold8pt, GREY1, "Messwerte: ", true, 10, 219, 220, 20, 5, GREY1);     // Übergabe an Funktion (Messwerte)

  // FEHLERCODEANZEIGE
  text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);     // Übergabe an Funktion (Fehlercodeanzeige)

  // ZURÜCK ZUR MAINPAGE
  text_with_frame(18, 278, &DialogBold8pt, GREY1, "MAIN", true, 10, 265, 45, 20, 5, GREY1);             // Übergabe an Funktion (Zurück zur Mainpage)
} // void sensorpage

// ------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------- //
// FUNKTION SETUP()
void setup()
{
  tft.init();
  //pinMode(ESP_ON, OUTPUT);          // ESP_ON als OUTPUT deklarieren
  //digitalWrite(ESP_ON, HIGH);

  WiFi.begin(ssid, password);       // Start des Internetzugangs
  
  pinMode(TFT_CS, OUTPUT);          // CS-Pin als OUTPUT deklariert
  pinMode(TFT_TOUCH_CS, OUTPUT);    // Touch-CS-Pin als OUTPUT deklariert

  digitalWrite(TFT_CS, HIGH);       // Grundzustand auf HIGH
  digitalWrite(TFT_TOUCH_CS, HIGH); // Grundzustand auf HIGH

  tft.begin();                      // Verbindung zum Display starten
  ts.begin();                       // Verbindung zum XPT2046 (Touch) starten
  EEPROM.begin(16);                 // Verbindung zum EEPROM herstellen mit 16 Byte Speicher
  tft.setRotation(2);               // Display drehen (0 / 0 --> Links oben)
  ts.setRotation(0);                // Touch drehen (kleinster Punkt --> Links oben)

  i_mainpage = 1;                   // Mainpage aufrufen
  b_mainpage = true;                // Mainpage laden

  m_x = readEEPROM(0);              // Ermitteln Korrekturfaktor
  m_y = readEEPROM(4);              // Ermitteln Korrekturfaktor
  n_xP = readEEPROM(8);             // Ermitteln Korrekturfaktor
  n_yP = readEEPROM(12);            // Ermitteln Korrekturfaktor
} // void setup()

// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //
// FUNKTION LOOP()
void loop()
{
  // -------- KEINE VERBINDUNG ZUM INTERNET VORHANDEN -------- //
  while (WiFi.status() != WL_CONNECTED)                                 // solange keine Internetverbindung besteht
  {
    if (i_mainpage == 1)                                                // aufrufen der Mainpage
    {
      mainpage();                                                       // Aufruf der Hauptseite
      text_with_frame(18, 303, &DialogBold8pt, GREY1, "WLAN-ZUSTAND: KEINE VERBINDUNG", true, 10, 290, 220, 20, 5, GREY1);         // Übergabe an Funktion (WLAN-Status)
      i_mainpage = 0;                                                   // Zähler zurücksetzen (einmaliges Aufrufen)
    } // if (i_mainpage == 1)

    yield();                                                            // Hintergrundprozesse erlauben
  } // while (WiFi.status() != WL_CONNECTED)

  i_mainpage = 1;                                                       // sobald Internetverbindung besteht, Zähler erneut setzen


  // -------- VERBINDUNG ZUM INTERNET VORHANDEN -------- //
  while (WiFi.status() == WL_CONNECTED)                                 // sobald Internetverbindung besteht
  {
    // -------- MAINPAGE -------- //
    if (i_mainpage == 1)                              // if Abfrage Mainpage aufrufen
    {
      if (b_mainpage)                                 // if Abfrage Mainpage laden
      {
        mainpage();                                   // Mainpage laden
        text_with_frame(18, 303, &DialogBold8pt, GREY1, "WLAN-ZUSTAND: VERBUNDEN", true, 10, 290, 220, 20, 5, GREY1);         // Übergabe an Funktion (WLAN-Status)
        b_mainpage = false;                           // Bool-Variable zurücksetzen (einmaliges laden)
      } // if (b_mainpage)

      ScreenPoint sp_main = ScreenPoint();            // Objekt erstellen

      if (ts.touched())                               // Touch registriert
      {
        TS_Point p = ts.getPoint();                   // Punkt ermitteln
        sp_main = getScreenPixel(p.x, p.y);           // in Pixel umwandeln

        // ZUR SOCKETPAGE //
        if ((sp_main.x >= 45) && (sp_main.x <= 195))    // Abfrage Pixelbereich x-Werte
        {
          if ((sp_main.y >= 75) && (sp_main.y <= 103))  // Abfrage Pixelbereich y-Werte
          {
            i_mainpage = 0;                             // Zähler für Mainpage zurücksetzen
            i_socketpage = 1;                           // Zähler für Socketpage setzen
            b_socketpage = true;                        // Bool für Socketpage setzen
          } // if ((sp_main.y >= 75) && (sp_main.y <= 103))

          // ZUR SENSORPAGE //
          else if ((sp_main.y >= 125) && (sp_main.y <= 153))  // else-if-Abfrage Pixelbereich y-Werte
          {
            i_mainpage = 0;                             // Zähler für Mainpage zurücksetzen
            i_sensorpage = 1;                           // Zähler für Sensorpage setzen
            b_sensorpage = true;                        // Bool für Sensorpage setzen
          } // else if ((sp_main.y >= 125) && (sp_main.y <= 153))
        } // if ((sp_main.x >= 45) && (sp_main.x <= 195))
      } // if (ts.touched())
      yield();                                         // Hintergrundprozesse erlauben
    } // if (i_mainpage == 1)


    // -------- SOCKETPAGE -------- //
    else if (i_socketpage == 1)                       // else-if-Abfrage Socketpage aufrufen
    {
      if (b_socketpage)                               // if-Abfrage Socketpage laden
      {
        socketpage();                                 // Socketpage laden
        b_socketpage = false;                         // Bool-Variable zurücksetzen (einmaliges laden)
      } // if (b_socketpage)

      ScreenPoint sp_socket = ScreenPoint();          // Objekt erstellen

      if (ts.touched())                               // Touch registriert
      {
        TS_Point p = ts.getPoint();                   // Punkt ermitteln
        sp_socket = getScreenPixel(p.x, p.y);         // in Pixel umwandeln

        // ZURÜCK ZUR MAINPAGE //
        if ((sp_socket.x >= 10) && (sp_socket.x <= 55) && (sp_socket.y >= 265) && (sp_socket.y <= 285)) // Abfrage Pixelbereich x- und y-Werte
        {
          i_socketpage = 0;                             // Zähler für Socketpage zurücksetzen
          i_mainpage = 1;                               // Zähler für Mainpage setzen
          b_mainpage = true;                            // Bool für Mainpage setzen
        } // if ((sp_socket.x >= 10) && (sp_socket.x <= 55) && (sp_socket.y >= 265) && (sp_socket.y <= 285))

        // --- SCHALTEN STECKDOSE SD 01 --- //
        else if ((sp_socket.y >= 60) && (sp_socket.y <= 88))      // else-if-Abfrage y-Pixelbereich
        {
          // ANSCHALTEN SD 01
          if ((sp_socket.x >= 122) && (sp_socket.x <= 172))       // if-Abfrage x-Pixelbereich
          {
            delay(150);                                               // kurz warten
            GET_REQUEST("http://192.168.2.113/cm?cmnd=Power%20On");   // Anfrage an Webseite per Funktionsaufruf

            if ((httpCode >= 200) && (httpCode < 300))            // Status-Code Abfrage
            {
              tft.fillRoundRect(122, 60, 50, 28, 5, BLUE2);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(137, 78, &DialogBold12pt, GREY1, "AN",  true, 122, 60, 50, 28, 5, GREY1);            // Übergabe an Funktion (AN-Feld)
              tft.fillRoundRect(180, 60, 50, 28, 5, BLUE1);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(190, 78, &DialogBold12pt, GREY1, "AUS",  true, 180, 60, 50, 28, 5, GREY1);           // Übergabe an Funktion (AUS-Feld)
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      // Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
            } // if ((httpCode >= 200) && (httpCode < 300))

            else                                                  // Fehlermeldung
            {
              sprintf(f_SD01, "SD 01: %i", httpCode);             // String formulieren
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      // Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
              text_with_frame(120, 303, &DialogBold8pt, GREY1, f_SD01, false, 0, 0, 0, 0, 0, 0);   // Ausgabe des Fehlercodes
            } // else
          } // if ((sp_socket.x >= 122) && (sp_socket.x <= 172))

          // AUSSCHALTEN SD 01
          else if ((sp_socket.x >= 180) && (sp_socket.x <= 230))  // else-if-Abfrage x-Pixelbereich
          {
            delay(150);                                               // kurz warten
            GET_REQUEST("http://192.168.2.113/cm?cmnd=Power%20Off");  // Anfrage an Webseite per Funktionsaufruf

            if ((httpCode >= 200) && (httpCode < 300))            // Status-Code Abfrage
            {
              tft.fillRoundRect(122, 60, 50, 28, 5, BLUE1);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(137, 78, &DialogBold12pt, GREY1, "AN",  true, 122, 60, 50, 28, 5, GREY1);            // Übergabe an Funktion (AN-Feld)
              tft.fillRoundRect(180, 60, 50, 28, 5, BLUE2);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(190, 78, &DialogBold12pt, GREY1, "AUS",  true, 180, 60, 50, 28, 5, GREY1);           // Übergabe an Funktion (AUS-Feld)
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      // Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
            } // if ((httpCode >= 200) && (httpCode < 300))

            else                                                  // Fehlermeldung
            {
              sprintf(f_SD01, "SD 01: %i", httpCode);             // String formulieren
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      // Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
              text_with_frame(120, 303, &DialogBold8pt, GREY1, f_SD01, false, 0, 0, 0, 0, 0, 0); // Ausgabe des Fehlercodes
            } // else
          } // else if ((sp_socket.x >= 180) && (sp_socket.x <= 230))
        } // else if ((sp_socket.y >= 60) && (sp_socket.y <= 88))

        // --- SCHALTEN STECKDOSE SD 02 --- //
        else if ((sp_socket.y >= 95) && (sp_socket.y <= 123))     // else-if Abfrage y-Pixelkoordinaten
        {
          // ANSCHALTEN SD 02
          if ((sp_socket.x >= 122) && (sp_socket.x <= 172))       // if-Abfrage x-Pixelkoordinaten
          {
            delay(150);                                               // kurz warten
            GET_REQUEST("http://192.168.2.114/cm?cmnd=Power%20On");   // Anfrage an Webseite per Funktionsaufruf

            if ((httpCode >= 200) && (httpCode < 300))            // if-Abfrage Status-Code
            {
              tft.fillRoundRect(122, 95, 50, 28, 5, BLUE2);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(137, 113, &DialogBold12pt, GREY1, "AN",  true, 122, 95, 50, 28, 5, GREY1);           // Übergabe an Funktion (AN-Feld)
              tft.fillRoundRect(180, 95, 50, 28, 5, BLUE1);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(190, 113, &DialogBold12pt, GREY1, "AUS",  true, 180, 95, 50, 28, 5, GREY1);          // Übergabe an Funktion (AUS-Feld)
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      // Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
            } // if ((httpCode >= 200) && (httpCode < 300))

            else                                                  // Fehlermeldung
            {
              sprintf(f_SD02, "SD 02: %i", httpCode);             // String formulieren
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      // Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
              text_with_frame(120, 303, &DialogBold8pt, GREY1, f_SD02, false, 0, 0, 0, 0, 0, 0); // Ausgabe des Fehlercodes
            } // else
          } // if ((sp_socket.x >= 122) && (sp_socket.x <= 172))

          // AUSSCHALTEN SD 02
          else if ((sp_socket.x >= 180) && (sp_socket.x <= 230))  // else-if Abfrage x-Pixelkoordinaten
          {
            delay(150);                                                 // kurz warten
            GET_REQUEST("http://192.168.2.114/cm?cmnd=Power%20Off");    // Anfrage an Webseite per Funktionsaufruf

            if ((httpCode >= 200) && (httpCode < 300))            // if-Abfrage Status-Code
            {
              tft.fillRoundRect(122, 95, 50, 28, 5, BLUE1);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(137, 113, &DialogBold12pt, GREY1, "AN",  true, 122, 95, 50, 28, 5, GREY1);           // Übergabe an Funktion (AN-Feld)
              tft.fillRoundRect(180, 95, 50, 28, 5, BLUE2);       // Schaltrechteck mit anderer Farbe füllen
              text_with_frame(190, 113, &DialogBold12pt, GREY1, "AUS",  true, 180, 95, 50, 28, 5, GREY1);          // Übergabe an Funktion (AUS-Feld)
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);      //Fehlercodeanzeige resetten
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
            } // if ((httpCode >= 200) && (httpCode < 300))

            else                                                  // Fehlermeldung
            {
              sprintf(f_SD02, "SD 02: %i", httpCode);             // String formulieren
              tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);
              text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);    // Übergabe an Funktion (Fehlercodeanzeige)
              text_with_frame(120, 303, &DialogBold8pt, GREY1, f_SD02, false, 0, 0, 0, 0, 0, 0);   // Ausgabe des Fehlercodes
            } // else
          } // else if ((sp_socket.x >= 180) && (sp_socket.x <= 230))
        } // else if ((sp_socket.y >= 95) && (sp_socket.y <= 123))
      } // if (ts.touched())
      yield();                                                    // Hintergrundprozesse erlauben
    } // if (i_socketpage == 1)


    // -------- SENSORPAGE -------- //
    if (i_sensorpage == 1)                            // else-if-Abfrage Sensorpage aufrufen
    {
      if (b_sensorpage)                               // if-Abfrage Sensorpage laden
      {
        sensorpage();                                 // Sensorpage laden
        b_sensorpage = false;                         // Bool-Variable zurücksetzen (einmaliges laden)
      } // if (b_sensorpage)

      ScreenPoint sp_sensor = ScreenPoint();          // Objekt erstellen

      if (ts.touched())                               // Touch registriert
      {
        TS_Point p = ts.getPoint();                   // Punkt ermitteln
        sp_sensor = getScreenPixel(p.x, p.y);         // in Pixel umwandeln

        // ZURÜCK ZUR MAINPAGE //
        if ((sp_sensor.x >= 10) && (sp_sensor.x <= 55) && (sp_sensor.y >= 265) && (sp_sensor.y <= 285)) // Abfrage Pixelbereich x- und y-Werte
        {
          i_sensorpage = 0;                             // Zähler für Sensorpage zurücksetzen
          i_mainpage = 1;                               // Zähler fär Mainpage setzen
          b_mainpage = true;                            // Bool für Mainpage setzen
        } // if ((sp_sensor.x >= 10) && (sp_sensor.x <= 55) && (sp_sensor.y >= 265) && (sp_sensor.y <= 285))

        // MESSUNG DHT11 //
        else if ((sp_sensor.x >= 115) && (sp_sensor.x <= 143) && (sp_sensor.y >= 60) && (sp_sensor.y <= 88))    // else-if-Abfrage x- und y-Pixelkoordinaten
        {
          delay(150);                                   // kurz warten
          String s_DHT11 = GET_REQUEST("http://192.168.2.115/cm?cmnd=Status%2010");   // Anfrage an Webseite per Funktionsaufruf

          if ((httpCode >= 200) && (httpCode < 300))                                  // if-Abfrage Status-Code
          {
            sprintf(t_DHT11, "T: %s [°C]   H: %s [%%]", s_DHT11.substring(66, 70), s_DHT11.substring(82, 86));    // String in Teilstrings zerlegen
            tft.fillRoundRect(10, 93, 220, 20, 5, BLUE1);           // Messwerte resetten
            text_with_frame(20, 106, &DialogBold8pt, GREY1, "Messwerte: ", true, 10, 93, 220, 20, 5, GREY1);      // Übergabe an Funktion (Messwerte)
            tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);          // Fehlercodeanzeige resetten
            text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);     // Übergabe an Funktion (Fehlercodeanzeige)
            text_with_frame(85, 106, &DialogBold8pt, GREY1, t_DHT11, false, 0, 0, 0, 0, 0, 0);                    // serielle Printausgabe
          } // if ((httpCode >= 200) && (httpCode < 300))

          else                                           // Fehlermeldung
          {
            sprintf(f_DHT11, "DHT11: %i", httpCode);     // String formulieren
            tft.fillRoundRect(10, 290, 220, 20, 5, BLUE1);          // Messwerte resetten
            text_with_frame(20, 303, &DialogBold8pt, GREY1, "Fehlercode:", true, 10, 290, 220, 20, 5, GREY1);     // Übergabe an Funktion (Fehlercodeanzeige)
            text_with_frame(120, 303, &DialogBold8pt, GREY1, f_DHT11, false, 0, 0, 0, 0, 0, 0);     // Ausgabe Fehlercode
          } // else
        } // else if ((sp_sensor.x >= 115) && (sp_sensor.x <= 143) && (sp_sensor.y >= 123) && (sp_sensor.y <= 151))
      } // if (i_sensorpage == 1)
    } // if (ts.touched())
    yield();                                              // Hintergrundprozesse erlauben
  } // while (WiFi.status() == WL_CONNECTED)

  i_mainpage = 1;                       // wenn erneut keine Internetverbindung, dann Mainpage aufrufen ermöglichen
} // void loop()

Wenn ich es richtig sehe, möchtest du den ESP im Setup einschalten. Aber wo möchtest du es ausschalten?

Ja das war der Plan. Vor dem Setup einschalten, wird vermutlich nicht funktionieren oder?

Vielleicht startet er dann zwar die TFT-Verbindung, weißt aber nicht so recht welche Pins er verwenden soll?

Ausschalten geht aktuell nur über einen RESET.. also eher unschön.. Wollte das ursprünglich über einen GPIO mittels Interrupt machen... also ein Taster, zum ein- und ausschalten. Dafür fehlt mir aber ein GPIO Pin um das zu machen. Gibt zwar noch GPIO 9 und 10 .. die werden aber anscheinend vom Flash genutzt und sind führen ein dauerhaftes HIGH-Signal

Nicht vor, sondern im Setup funktioniert es.
Da du ein Touch-Display verwendest, kannst du doch einen Taster zeichnen und mit dem den geeigneten Pin auch wieder ausschalten.

Welche Pins du am ESP8266 verwenden kannst/darfst kannst du hier nachschauen.

Muss ich mit mir selbst noch einig werden, ob ich das Ausschalten im Menü integriere als Button oder als externen Taster mache.

Manche Pins haben ja "vorgefertigte" Pegel. Darf ich diese Pegel den bereits in der setup() verändern oder sollte ich diese erst im loop() anpassen, wie ich sie brauche?!

setup() heißt einfach nur dass es nur einmal ausgeführt wird. Mehr darfst du da nicht reinlesen

Alles klar! :+1:

Ja mittlerweile glaube ich doch, dass der ILI9341 Treiberchip vom Display etwas abbekommen hat. Habe mit einer anderen NodeMCU unterschiedliche Programmcodes mit unterschiedlichen Pinbelegungen ausprobiert. Jedes Mal bliebt der Bildschirm weiß, was definitiv nicht sein darf.. Klar könnten auch die NodeMCUs etwas abbekommen haben, aber davon gehe ich nicht aus.

Gäbe jetzt natürlich noch die Möglichkeit kein HardwareSPI zu nutzen, sondern das auch mal mit SoftwareSPI zu machen.. denke aber nicht, dass das etwas ändern sollte.. oder was meint ihr?

Kann ich eigentlich die SPI-Pins auf der anderen Seite der NodeMCU nutzen? Also diejenigen die mit dem Flash verbunden sein sollen?

Nein, def. nicht.

Und was soll es ändern, wenn du Soft-SPI nutzt ?
Da machst du dir nur weitere Probleme.

Baue einen einfachen (Test) Sketch für das Display auf, ohne irgend welchen Firlefanz.
Dann siehst du, ob noch alles oder nichts funktioniert.

Und vorgefertigte Pegel gibt es nur an den Pins, wie sie in meinem Link beschrieben sind.
Alle anderen "normalen GPIO" darfst du individuell anpassen.

Und wenn du es als Touch-Button auslegst, benötigst du keinen extra Pin.

Frag mich dann, weshalb sich der Hersteller dachte, die dann nach draußen zu führen.. Naja wie dem auch sei. ^^

Ist wohl das Beste. Schade, dass man den nicht auch auswechseln kann.. Aber jut, noch kann ich das Board wieder zurück schicken.

Denke, ich werds auch im Endeffekt mit nem Touchbutton umsetzen.

Danke für eure Hilfe.

Was auswechseln ?
Hast du geprüft, was defekt ist ?
Die Pins sind rausgeführt, um evtl. den Speicher zu erweitern.

Man kann den ILI9341 nicht auswechseln.

Wie kann ich den den ILI9341 prüfen?! Außer einen Sketch zu schreiben und zu gucken ob er das anzeigt oder nicht.

Klar, macht Sinn mit der Erweiterung.

Ok, wenn tatsächlich der ILI9341 defekt ist, hast du keine Chance als das Display komplett zu tauschen. Da hilft dir auch Soft-SPI nicht weiter.

Das meinte ich ja. Wenn er selbst eine Hintergrundfarbe nicht mehr anzeigen kann, dann hats den wohl zerledert... Aber trotzdem fragwürdig wie das passieren kann

Da mir das bisher noch nicht passiert ist, obwohl ich schon einige der SPI-TFT eingesetzt habe, mein Tipp nochmals die komplette Verdrahtung prüfen und evtl. neu verlegen.

Jaa, werde ich dann machen. Hat ja vorher funktioniert.. Bis dann halt der MOSFET hinzukam

Du hast ja auch mal den GND weggeschaltet, da kann durchaus etwas schief gegangen sein. Deshalb sollte man das nie machen.

Das kann gut möglich sein. Aus Fehlern lernt man.

ILI ist sehr impfintlich wen die kein GND haben und mit Daten befeuert werden, es gibt noch dazu 8 Bit TFT was "vertragen" 5V, ohne GND stinken die einewig den die Indianerzeichen sind nicht sichtbar =Rauchzeichen
hab so einen platt gemach :frowning:

Nadann wird es vermutlich an meinem "Experiment" mit dem N-MOSFET gelegen haben.

Ärgerlich, aber gut zu wissen.

Mal noch eine Frage. Es gibt dieses 2,8 Zoll TFT-Displays in Version 1.1 und 1.2.. Wisst ihr ob die sich gleich programmieren lassen oder muss ich bei der Version 1.1 etwas besonderes beachten?