Newbie Arduino Display

Ich habe mir mein Bildschirm mit esp32 micro gekauft. Genaue Bezeichnung ist : 3,5 Zoll LCD-TFT-Modul esp32 Arduino lvgl WLAN & Bluetooth-Entwicklungs board 2.8 "240*320 Smart-Display-Bildschirm mit TouchLink:(https://de.aliexpress.com/item/1005006398972223.html?spm=a2g0o.order_list.order_list_main.5.60545c5fD1QGVO&gatewayAdapt=glo2deu)

Habe mir dann die Software heruntergeladen und mich durch die Manuel durchgearbeitet und den sketch am ende kopiert. Bei Schluss wo ich den Sketch eingefügt habe kam einige zeilenfehler die ich durch // weg bekommen habe. Ich habe mir dann die datei 3.5inch_ESP32-3248S035 heruntergeladen wo ich alles drinne ist.

jetzt:

//basic settings
//#TFT_eSPI.init(); //initialization
//initialize the screen, if it is ST7796, you can pass a parameter to it, and see when it is used .
//tft.fillScreen(TFT_BLACK); //fill full screen fill full screen, followed by color values.
//tft.fillScreen(uint32_t color);
//Screen rotation
// Set the rotation angle of the screen display, the parameters are: 0, 1, 2, 3
// Represent 0°, 90°, 180°, 270°
void setRotation(uint8_t r);
//Screen inversion
//Invert display colors i = 1 invert, i = 0 normal
//tft.invertDisplay(bool i);

//Text related API
//tft.setCursor(20, 10, 4); //Set the starting coordinate position and font size of typing
// Set the text display coordinates. By default, the upper left corner of the text is used as the reference point. The reference point can be changed.
void setCursor(int16_t x, int16_t y);
// Set the text display coordinates, and the font of the text
void setCursor(int16_t x, int16_t y, uint8_t font);
//tft.setTextColor(2); //Set font color
// Set text color
void setTextColor(uint16_t color);
// Set text color and background color
void setTextColor(uint16_t fgcolor, uint16_t bgcolor);
//Setting the background color can effectively prevent numbers from overlapping
//tft.setTextSize(2); //Set font size
//Setting the text size can enlarge the display of the font, but the "resolution" of the font will not change
// Set the text size, the text size range is an integer from 1 to 7
void setTextSize(uint8_t size);
//tft.print("Hello World!");
// Display font
//tft.print("Hello World!");
//tft.printf, tft.println //Display font
//Special Note: Font 7 is an imitation of a 7-segment digital screen

//APIs related to drawing text
//Draw the string (left)
//int16_t drawString(const String &string, int32_t x, int32_t y)
//int16_t drawString(const char * string, int32_t x, int32_t y)
//int16_t drawString(const String &string, int32_t x, int32_t y, uint8_t font)
//int16_t drawString(const char * string, int32_t x, int32_t y, uint8_t font)
//Draw the string (centered)
//int16_t drawCentreString(const char * string, int32_t x, int32_t y, uint8_t font)
//int16_t drawCentreString(const String &string, int32_t x, int32_t y, uint8_t font)
//Draw the string (right)
//int16_t drawRightString(const char * string, int32_t x, int32_t y, uint8_t font)
//int16_t drawRightString(const String &string, int32_t x, int32_t y, uint8_t font)
//Drawing characters
//int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y)int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font)
//void drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_tsize)
//Plot floating point numbers
//int16_t TFT_eSPI::drawFloat(float floatNumber, uint8_t decimal, int32_t x, int32_t y)
//int16_t TFT_eSPI::drawFloat(float floatNumber, uint8_t decimal, int32_t x, int32_t y,uint8_t font)
//tft.drawFloat(3.124, 4, 0,0,4);
//Draw the numbers
//int16_t drawNumber(long intNumber, int32_t x, int32_t y)
//int16_t drawNumber(long intNumber, int32_t x, int32_t y, uint8_t font)

//Drawing geometric figures
//Draw the dots
//void drawPixel(int32_t x, int32_t y, uint32_t color)
//Draw lines
////void drawLine(int32_t xs, int32_t ys, int32_t xe, int32_t ye, uint32_t color)
//Draw a horizontal line (quick)
//void drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
//Draw a vertical line (quick)
//void drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
//Draw the hollow circle
//tft.drawCircle(100, 100,50,TFT_RED);
//Draw a filled circle
//void fillCircle(int32_t x, int32_t y, int32_t r, uint32_t color)
//Draw a hollow ellipse
//tft.drawEllipse(100, 100, 100,60,TFT_GREENYELLOW);
//Draw a solid ellipse
//void drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
//Draw a hollow rectangle
//void drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
//Draw a solid rectangle
//void fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
//Draw a hollow rounded rectangle
//void drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_tcolor)
//Draw a solid rounded rectangle
//void fillRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_tcolor)
//Draw Hollow Triangles
//void drawTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3,uint32_t color)
//Draw Solid Triangles
//void fillTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3,uint32_t color)

//Image display related
//Display BMP picture
//void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor)
//void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor, uint16_t bgcolor)
//XBM
//xbm is a simple two-color image bitmap format, which was widely used in early cgi and is currently
//used in counters. Here TFT_eSPI recommends an online XBM production toolxbm is a simple two-color
//image bitmap format, which was widely used in early cgi and is currently used in counters. Here
//TFT_eSPI recommends an online XBM production tool
//https://www.online-utility.org/image/convert/to/XBM
//Test is very useful
//void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor)
//void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor, uint16_t bgcolor)
//Display pictures
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data) 
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data,uint16_t transparent)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data, uint16_ttransparent)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data, bool bpp8 = true, uint16_t *cmap = (uint16_t *)nullptr)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data, uint8_t transparent, bool bpp8 = true, uint16_t *cmap = (uint16_t *)nullptr)''

Jetzt habe ich keine Fehlermeldung von der Zeilen her aber dafür bekommenich jetzt bei komplilierendie Fehlermeldung:

Arduino: 1.8.19 (Windows 10), Board: "ESP32 Dev Module, Disabled, Disabled, Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS), 240MHz (WiFi/BT), DIO, 80MHz, 4MB (32Mb), 115200, Core 1, Core 1, None, Disabled, Disabled"

C:/Users/Matze/AppData/Local/Arduino15/packages/esp32/tools/esp-x32/2601/bin/../lib/gcc/xtensa-esp-elf/14.2.0/../../../../xtensa-esp-elf/bin/ld.exe: C:\Users\Matze\AppData\Local\Temp\arduino_cache_977386\core\core_3562e3288b734e41e0668dea013917f7.a(Main.cpp.o):(.literal._Z8loopTaskPv+0xc): undefined reference to `setup()'

C:/Users/Matze/AppData/Local/Arduino15/packages/esp32/tools/esp-x32/2601/bin/../lib/gcc/xtensa-esp-elf/14.2.0/../../../../xtensa-esp-elf/bin/ld.exe: C:\Users\Matze\AppData\Local\Temp\arduino_cache_977386\core\core_3562e3288b734e41e0668dea013917f7.a(Main.cpp.o):(.literal._Z8loopTaskPv+0x10): undefined reference to `loop()'

C:/Users/Matze/AppData/Local/Arduino15/packages/esp32/tools/esp-x32/2601/bin/../lib/gcc/xtensa-esp-elf/14.2.0/../../../../xtensa-esp-elf/bin/ld.exe: C:\Users\Matze\AppData\Local\Temp\arduino_cache_977386\core\core_3562e3288b734e41e0668dea013917f7.a(Main.cpp.o): in function `loopTask(void*)':

C:\Users\Matze\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.3.11\cores\esp32/Main.cpp:63:(.text._Z8loopTaskPv+0x22): undefined reference to `setup()'

C:/Users/Matze/AppData/Local/Arduino15/packages/esp32/tools/esp-x32/2601/bin/../lib/gcc/xtensa-esp-elf/14.2.0/../../../../xtensa-esp-elf/bin/ld.exe: C:\Users\Matze\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.3.11\cores\esp32/Main.cpp:71:(.text._Z8loopTaskPv+0x3b): undefined reference to `loop()'

collect2.exe: error: ld returned 1 exit status

exit status 1

Fehler beim Kompilieren für das Board ESP32 Dev Module.

Was mache ich verkehrt oder wo ist der Fehler?

Das Display sollte eigentlich für bambuhelper genutzt werden?

Danke für die Hilfe

Lies dir bitte den Beitrag durch, Wie man dieses Furum nutzt. und poste auch einen Link des verwendeten Displays.

Und was soll das sein ?

Zeige Link zum Display so was wie du das beschreibt gibt es nich.
Von den gelben Display gibt's zwei Sorten Software als Beispiele, wenn später zu Hause bin kann dir helfen. Vor allem muss du die UserSetup für das Display in die TFT_e SPI kopieren sonst funktioniert das Display nicht. Ach ja ich kenne kein 3,5" Display mit 240x320 Auflösung, auch die gelbe nicht also nochmal Link zeigenj

Die Bambuhelper was ich kenne sind im Python geschrieben, also viel Spass mit der TFT_eSPI

Unter anderem enthält dein Projekt nicht den Haupt-Einstiegssketch, der bei Arduino immer diese zwei Funktionen enthält. Hast du die auch auskommentiert?
Was sonst noch falsch ist, kann man schlecht erkennen.

Bei Schluss wo ich den Sketch eingefügt habe kam einige zeilenfehler die ich durch // weg bekommen habe

Ob das (wobei?) etwas verbessert, ist auch fraglich.
Falls die Anleitung, die du verwendest, narrensicher ist und zu deiner Hardware passt, fang nochmal von vorn an ,,, :upside_down_face:

Wenn man den von Dir geposteten Text formatiert und in Code-Tags darstellt, sieht das so aus:

//basic settings
//#TFT_eSPI.init(); //initialization
//initialize the screen, if it is ST7796, you can pass a parameter to it, and see when it is used .
//tft.fillScreen(TFT_BLACK); //fill full screen fill full screen, followed by color values.
//tft.fillScreen(uint32_t color);
//Screen rotation
// Set the rotation angle of the screen display, the parameters are: 0, 1, 2, 3
// Represent 0°, 90°, 180°, 270°
void setRotation(uint8_t r);
//Screen inversion
//Invert display colors i = 1 invert, i = 0 normal
//tft.invertDisplay(bool i);

//Text related API
//tft.setCursor(20, 10, 4); //Set the starting coordinate position and font size of typing
// Set the text display coordinates. By default, the upper left corner of the text is used as the reference point. The reference point can be changed.
void setCursor(int16_t x, int16_t y);
// Set the text display coordinates, and the font of the text
void setCursor(int16_t x, int16_t y, uint8_t font);
//tft.setTextColor(2); //Set font color
// Set text color
void setTextColor(uint16_t color);
// Set text color and background color
void setTextColor(uint16_t fgcolor, uint16_t bgcolor);
//Setting the background color can effectively prevent numbers from overlapping
//tft.setTextSize(2); //Set font size
//Setting the text size can enlarge the display of the font, but the "resolution" of the font will not change
// Set the text size, the text size range is an integer from 1 to 7
void setTextSize(uint8_t size);
//tft.print("Hello World!");
// Display font
//tft.print("Hello World!");
//tft.printf, tft.println //Display font
//Special Note: Font 7 is an imitation of a 7-segment digital screen

//APIs related to drawing text
//Draw the string (left)
//int16_t drawString(const String &string, int32_t x, int32_t y)
//int16_t drawString(const char * string, int32_t x, int32_t y)
//int16_t drawString(const String &string, int32_t x, int32_t y, uint8_t font)
//int16_t drawString(const char * string, int32_t x, int32_t y, uint8_t font)
//Draw the string (centered)
//int16_t drawCentreString(const char * string, int32_t x, int32_t y, uint8_t font)
//int16_t drawCentreString(const String &string, int32_t x, int32_t y, uint8_t font)
//Draw the string (right)
//int16_t drawRightString(const char * string, int32_t x, int32_t y, uint8_t font)
//int16_t drawRightString(const String &string, int32_t x, int32_t y, uint8_t font)
//Drawing characters
//int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y)int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font)
//void drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_tsize)
//Plot floating point numbers
//int16_t TFT_eSPI::drawFloat(float floatNumber, uint8_t decimal, int32_t x, int32_t y)
//int16_t TFT_eSPI::drawFloat(float floatNumber, uint8_t decimal, int32_t x, int32_t y,uint8_t font)
//tft.drawFloat(3.124, 4, 0,0,4);
//Draw the numbers
//int16_t drawNumber(long intNumber, int32_t x, int32_t y)
//int16_t drawNumber(long intNumber, int32_t x, int32_t y, uint8_t font)

//Drawing geometric figures
//Draw the dots
//void drawPixel(int32_t x, int32_t y, uint32_t color)
//Draw lines
////void drawLine(int32_t xs, int32_t ys, int32_t xe, int32_t ye, uint32_t color)
//Draw a horizontal line (quick)
//void drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
//Draw a vertical line (quick)
//void drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
//Draw the hollow circle
//tft.drawCircle(100, 100,50,TFT_RED);
//Draw a filled circle
//void fillCircle(int32_t x, int32_t y, int32_t r, uint32_t color)
//Draw a hollow ellipse
//tft.drawEllipse(100, 100, 100,60,TFT_GREENYELLOW);
//Draw a solid ellipse
//void drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
//Draw a hollow rectangle
//void drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
//Draw a solid rectangle
//void fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
//Draw a hollow rounded rectangle
//void drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_tcolor)
//Draw a solid rounded rectangle
//void fillRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_tcolor)
//Draw Hollow Triangles
//void drawTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3,uint32_t color)
//Draw Solid Triangles
//void fillTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3,uint32_t color)

//Image display related
//Display BMP picture
//void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor)
//void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor, uint16_t bgcolor)
//XBM
//xbm is a simple two-color image bitmap format, which was widely used in early cgi and is currently
//used in counters. Here TFT_eSPI recommends an online XBM production toolxbm is a simple two-color
//image bitmap format, which was widely used in early cgi and is currently used in counters. Here
//TFT_eSPI recommends an online XBM production tool
//Convert Image to XBM
//Test is very useful
//void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor)
//void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h,uint16_t fgcolor, uint16_t bgcolor)
//Display pictures
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data,uint16_t transparent)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data, uint16_ttransparent)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data, bool bpp8 = true, uint16_t *cmap = (uint16_t *)nullptr)
//void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data, uint8_t transparent, bool bpp8 = true, uint16_t *cmap = (uint16_t *)nullptr)

Der Code ist (vorsichtig formuliert) unvollständig.

Poste doch mal den Code, den Du heruntergeladen hast, ohne Änderungen.
Oder zumindest einen Link auf die Quelle ...

Hast Du u.U. einfach den Text aus der PDF-Beschreibung kopiert?

Das ist kein vollständiger Code, sondern eine aus dem Chinesischen (vermutlich automatisch) ins Englische übersetzte Beschreibung von Software-Funktionen.

Der eigentliche, vollständige Code (bis auf die separat zu installierenden Libraries) sollte sich in den Beispielverzeichnissen befinden (Achtung, die rote Markierung kommt nicht von mir, sondern ist in der PDF vorhanden; Du musst Dir selbst die gewünschte Datei heraussuchen; fang am besten mit "Helloworld" an! Erst wenn das funktioniert, zum nächsten Beispiel weitergehen!!!!):

In der Regel enden die dort abgelegten Dateien auf .ino

Jede Reise (auch die ins Arduino-Universum) beginnt mit dem ersten Schritt, Du hast noch einige vor Dir ... Viel zu lernen Du noch hast, junger Padawan
:innocent: :sweat_smile: :wink:

Nicht aufgeben, hier wird Dir schon geholfen!
ec2021

P.S.: Wer rätselt, wie ich auf diesen Verdacht gekommen bin:

a) Frage an die KI

Woher stammt dieses Fragment
//initialize the screen, if it is ST7796, you can pass a parameter to it, and see when it is used .
tft.fillScreen(TFT_BLACK); //fill full screen fill full screen, followed by color values.

b) Gefolgt von der ergänzenden Frage:

Wo findet man exakt(!) den Text und diese Reihenfolge?

ergab die Antwort (Auszug)

Zeige Link zum Display so was wie du das beschreibt gibt es nich.
Von den gelben Display gibt's zwei Sorten Software als Beispiele, wenn später zu Hause bin kann dir helfen. Vor allem muss du die UserSetup für das Display in die TFT_e SPI kopieren sonst funktioniert das Display nicht.

Hast wo möglich die neue Software bei meiner funktionieren die TFT_eSPI Beispiele.

Ein Missverständnis?

Der TO hat allem Anschein nach nicht die Beispielsoftware verwendet, sondern die Funktionsbeschreibung aus der zugehörigen PDF kopiert ...

Wenn Du Dir den ersten Screenshot in meinem Post 8 anschaust, erkennst Du genau die Formulierungen wieder, wie sie auch im Text von Post 1 zu lesen sind.

Die Beispiele aus den Demo-Verzeichnissen werden schon funktionieren, aber das, was der TO verwendet hat, ist kein funktionsfähiger Code sondern eine Funktionsbeschreibung ...

@ec2021
Für welchen Display hast die datei ?
Wen ich gutt in erinnerung habe sind die Demo nicht gleich. Was für Display @matze1312 hat wissen wir nicht die Angaben sind für die Katz

@matze1312
Es wehre schön mal antworten.

Der TO hat offensichtlich einen Text zu kompilieren versucht, der gar kein Code, sondern eine aus kopierte Funktionsbeschreibung ist.

Sie stammt vermutlich aus dieser (oder einer ähnlichen) Quelle:

https://content.instructables.com/FSK/W4RY/MJOYOQ70/FSKW4RYMJOYOQ70.pdf

Schau Dir das PDF ab Seite 20 an ... Die dortige Beschreibung entspricht weitgehend dem vom TO in Post 1 einkopierten Text.

In der PDF wird beschrieben, wie man vorzugehen hat. Die Beispiele werden mit der TFT_eSPI Library installiert. Ebenso wird das Vorgehen mit User_Setup.h erläutert.

@matze1312 : Wäre echt gut, wenn Du einen Link auf Deine Hardware posten würdest, damit wir sicher sind, welche Konfiguration Du tatsächlich hast. Wie oben beschrieben, der Text am Ende der Doku ist kein Sketch!!

Aufgrund der Bezeichnung rate ich:
Das ist ein Komplettset: ESP32-2432S028R

Das angepasste User-Setup

SD-Karte:
CS    5
SCLK 18
MISO 19
RST  22
MOSI 23

Der Display ist ILI9341_DRIVER

DC 2
MISO 12 
MOSI 13 
CLK 14 
CS 15 

BL - wenn gebraucht - 21

Der Touch ist ein XPT2046 mit:

CLK 25
DI  32
CS  33
IRQ 36
DO  39

RGB-LED:

rot 4
gelb 16
blau 17

Mach was draus.

Edit: Vollständige Belegung der gesamten Perepherie.

Na ja wenn der ein
ESP32-3248S0535 mit Kapazitiven Touch hat stimmen deine Angaben nicht. Zu dem vom beiden Sorten werden mindenst 3 von unterschidlichen Hersteller gebaut.
Noch was, in der pasender Datei ist immer eine User_Stup.h mit dabei.
Ab manchen 4" CYD Displays nichtmehr, die unterstützt Bodmer noch nicht.
Ach ja Für 2,8 Displays gibt es auch welche mit I2C Touch.

Also dein Vorschlag kann hinhauen muss aber nicht.
Die Bl hast nicht gezeigt für dein Vorschlag ist es GPIO 27, oder 21

So jetzt sitze vor Rechner weiß nicht woher hast die Daten für den ESP32-2432S028R genommen die User_Setup.h

//                            USER DEFINED SETTINGS
//   Set driver type, fonts to be loaded, pins used and SPI control method etc
//
//   See the User_Setup_Select.h file if you wish to be able to define multiple
//   setups and then easily select which setup file is used by the compiler.
//
//   If this file is edited correctly then all the library example sketches should
//   run without the need to make any more changes for a particular hardware setup!
//   Note that some sketches are designed for a particular TFT pixel width/height


// ##################################################################################
//
// Section 1. Call up the right driver file and any options for it
//
// ##################################################################################

// Define STM32 to invoke optimised processor support (only for STM32)
//#define STM32

// Defining the STM32 board allows the library to optimise the performance
// for UNO compatible "MCUfriend" style shields
//#define NUCLEO_64_TFT
//#define NUCLEO_144_TFT

// STM32 8 bit parallel only:
// If STN32 Port A or B pins 0-7 are used for 8 bit parallel data bus bits 0-7
// then this will improve rendering performance by a factor of ~8x
//#define STM_PORTA_DATA_BUS
//#define STM_PORTB_DATA_BUS

// Tell the library to use 8 bit parallel mode (otherwise SPI is assumed)
//#define TFT_PARALLEL_8_BIT

// Display type -  only define if RPi display
//#define RPI_DISPLAY_TYPE // 20MHz maximum SPI

// Only define one driver, the other ones must be commented out
//#define ILI9341_DRIVER       // Generic driver for common displays
#define ILI9341_2_DRIVER     // Alternative ILI9341 driver, see https://github.com/Bodmer/TFT_eSPI/issues/1172
//#define ST7735_DRIVER      // Define additional parameters below for this display
//#define ILI9163_DRIVER     // Define additional parameters below for this display
//#define S6D02A1_DRIVER
//#define RPI_ILI9486_DRIVER // 20MHz maximum SPI
//#define HX8357D_DRIVER
//#define ILI9481_DRIVER
//#define ILI9486_DRIVER
//define ILI9488_DRIVER     // WARNING: Do not connect ILI9488 display SDO to MISO if other devices share the SPI bus (TFT SDO does NOT tristate when CS is high)
//#define ST7789_DRIVER      // Full configuration option, define additional parameters below for this display
//#define ST7789_2_DRIVER    // Minimal configuration option, define additional parameters below for this display
//#define R61581_DRIVER
//#define RM68140_DRIVER
//#define ST7796_DRIVER
//#define SSD1351_DRIVER
//#define SSD1963_480_DRIVER
//#define SSD1963_800_DRIVER
//#define SSD1963_800ALT_DRIVER
//#define ILI9225_DRIVER
//#define GC9A01_DRIVER

// Some displays support SPI reads via the MISO pin, other displays have a single
// bi-directional SDA pin and the library will try to read this via the MOSI line.
// To use the SDA line for reading data from the TFT uncomment the following line:

// #define TFT_SDA_READ      // This option is for ESP32 ONLY, tested with ST7789 and GC9A01 display only

// For ST7735, ST7789 and ILI9341 ONLY, define the colour order IF the blue and red are swapped on your display
// Try ONE option at a time to find the correct colour order for your display

//  #define TFT_RGB_ORDER TFT_RGB  // Colour order Red-Green-Blue
//  #define TFT_RGB_ORDER TFT_BGR  // Colour order Blue-Green-Red

// For M5Stack ESP32 module with integrated ILI9341 display ONLY, remove // in line below

// #define M5STACK

// For ST7789, ST7735, ILI9163 and GC9A01 ONLY, define the pixel width and height in portrait orientation
// #define TFT_WIDTH  80
// #define TFT_WIDTH  128
// #define TFT_WIDTH  128 // ST7789 240 x 240 and 240 x 320
#define TFT_WIDTH  240
// #define TFT_WIDTH  320
// #define TFT_HEIGHT 160
// #define TFT_HEIGHT 128
//#define TFT_HEIGHT 160 // ST7789 240 x 240
 #define TFT_HEIGHT 320 // ST7789 240 x 320
// #define TFT_HEIGHT 240 // GC9A01 240 x 240 //#define TFT_HEIGHT 480

// For ST7735 ONLY, define the type of display, originally this was based on the
// colour of the tab on the screen protector film but this is not always true, so try
// out the different options below if the screen does not display graphics correctly,
// e.g. colours wrong, mirror images, or stray pixels at the edges.
// Comment out ALL BUT ONE of these options for a ST7735 display driver, save this
// this User_Setup file, then rebuild and upload the sketch to the board again:

// #define ST7735_INITB
// #define ST7735_GREENTAB
// #define ST7735_GREENTAB2
// #define ST7735_GREENTAB3
// #define ST7735_GREENTAB128    // For 128 x 128 display
// #define ST7735_GREENTAB160x80 // For 160 x 80 display (BGR, inverted, 26 offset)
// #define ST7735_REDTAB
// #define ST7735_BLACKTAB
// #define ST7735_REDTAB160x80   // For 160 x 80 display with 24 pixel offset

// If colours are inverted (white shows as black) then uncomment one of the next
// 2 lines try both options, one of the options should correct the inversion.

// #define TFT_INVERSION_ON
// #define TFT_INVERSION_OFF


// ##################################################################################
//
// Section 2. Define the pins that are used to interface with the display here
//
// ##################################################################################

// If a backlight control signal is available then define the TFT_BL pin in Section 2
// below. The backlight will be turned ON when tft.begin() is called, but the library
// needs to know if the LEDs are ON with the pin HIGH or LOW. If the LEDs are to be
// driven with a PWM signal or turned OFF/ON then this must be handled by the user
// sketch. e.g. with digitalWrite(TFT_BL, LOW);

 #define TFT_BL   21            // LED back-light control pin
 #define TFT_BACKLIGHT_ON HIGH  // Level to turn ON back-light (HIGH or LOW)



// We must use hardware SPI, a minimum of 3 GPIO pins is needed.
// Typical setup for ESP8266 NodeMCU ESP-12 is :
//
// Display SDO/MISO  to NodeMCU pin D6 (or leave disconnected if not reading TFT)
// Display LED       to NodeMCU pin VIN (or 5V, see below)
// Display SCK       to NodeMCU pin D5
// Display SDI/MOSI  to NodeMCU pin D7
// Display DC (RS/AO)to NodeMCU pin D3
// Display RESET     to NodeMCU pin D4 (or RST, see below)
// Display CS        to NodeMCU pin D8 (or GND, see below)
// Display GND       to NodeMCU pin GND (0V)
// Display VCC       to NodeMCU 5V or 3.3V
//
// The TFT RESET pin can be connected to the NodeMCU RST pin or 3.3V to free up a control pin
//
// The DC (Data Command) pin may be labelled AO or RS (Register Select)
//
// With some displays such as the ILI9341 the TFT CS pin can be connected to GND if no more
// SPI devices (e.g. an SD Card) are connected, in this case comment out the #define TFT_CS
// line below so it is NOT defined. Other displays such at the ST7735 require the TFT CS pin
// to be toggled during setup, so in these cases the TFT_CS line must be defined and connected.
//
// The NodeMCU D0 pin can be used for RST
//
//
// Note: only some versions of the NodeMCU provide the USB 5V on the VIN pin
// If 5V is not available at a pin you can use 3.3V but backlight brightness
// will be lower.


// ###### EDIT THE PIN NUMBERS IN THE LINES FOLLOWING TO SUIT YOUR ESP8266 SETUP ######

// For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation
//#define TFT_CS   PIN_D8  // Chip select control pin D8
//#define TFT_DC   PIN_D3  // Data Command control pin
//#define TFT_RST  PIN_D4  // Reset pin (could connect to NodeMCU RST, see next line)
//#define TFT_RST  -1    // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V

//#define TFT_BL PIN_D1  // LED back-light (only for ST7789 with backlight control pin)

//#define TOUCH_CS PIN_D2     // Chip select pin (T_CS) of touch screen

//#define TFT_WR PIN_D2       // Write strobe for modified Raspberry Pi TFT only


// ######  FOR ESP8266 OVERLAP MODE EDIT THE PIN NUMBERS IN THE FOLLOWING LINES  ######

// Overlap mode shares the ESP8266 FLASH SPI bus with the TFT so has a performance impact
// but saves pins for other functions. It is best not to connect MISO as some displays
// do not tristate that line when chip select is high!
// On NodeMCU 1.0 SD0=MISO, SD1=MOSI, CLK=SCLK to connect to TFT in overlap mode
// On NodeMCU V3  S0 =MISO, S1 =MOSI, S2 =SCLK
// In ESP8266 overlap mode the following must be defined

//#define TFT_SPI_OVERLAP

// In ESP8266 overlap mode the TFT chip select MUST connect to pin D3
//#define TFT_CS   PIN_D3
//#define TFT_DC   PIN_D5  // Data Command control pin
//#define TFT_RST  PIN_D4  // Reset pin (could connect to NodeMCU RST, see next line)
//#define TFT_RST  -1  // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V


// ###### EDIT THE PIN NUMBERS IN THE LINES FOLLOWING TO SUIT YOUR ESP32 SETUP   ######

// For ESP32 Dev board (only tested with ILI9341 display)
// The hardware SPI can be mapped to any pins

// #define TFT_MISO -1 
// #define TFT_MOSI 14
// #define TFT_SCLK 33
// #define TFT_CS   -1  // Chip select control pin
// #define TFT_DC    13  // Data Command control pin
// #define TFT_RST   12  // Reset pin (could connect to RST pin)
//#define TFT_RST  -1  // Set TFT_RST to -1 if display RESET is connected to ESP32 board RST

// For ESP32 Dev board (only tested with GC9A01 display)
// The hardware SPI can be mapped to any pins

#define TFT_MOSI 13 // In some display driver board, it might be written as "SDA" and so on.
#define TFT_SCLK 14
#define TFT_CS   15  // Chip select control pin
#define TFT_DC   2  // Data Command control pin
#define TFT_RST  12  // Reset pin (could connect to Arduino RESET pin)
#define TFT_BL   21  // LED back-light

#define TOUCH_CS 33     // Chip select pin (T_CS) of touch screen

//#define TFT_WR 22    // Write strobe for modified Raspberry Pi TFT only

// For the M5Stack module use these #define lines
//#define TFT_MISO 19
//#define TFT_MOSI 23
//#define TFT_SCLK 18
//#define TFT_CS   14  // Chip select control pin
//#define TFT_DC   27  // Data Command control pin
//#define TFT_RST  33  // Reset pin (could connect to Arduino RESET pin)
//#define TFT_BL   32  // LED back-light (required for M5Stack)

// ######       EDIT THE PINs BELOW TO SUIT YOUR ESP32 PARALLEL TFT SETUP        ######

// The library supports 8 bit parallel TFTs with the ESP32, the pin
// selection below is compatible with ESP32 boards in UNO format.
// Wemos D32 boards need to be modified, see diagram in Tools folder.
// Only ILI9481 and ILI9341 based displays have been tested!

// Parallel bus is only supported for the STM32 and ESP32
// Example below is for ESP32 Parallel interface with UNO displays

// Tell the library to use 8 bit parallel mode (otherwise SPI is assumed)
//#define TFT_PARALLEL_8_BIT

// The ESP32 and TFT the pins used for testing are:
//#define TFT_CS   33  // Chip select control pin (library pulls permanently low
//#define TFT_DC   15  // Data Command control pin - must use a pin in the range 0-31
//#define TFT_RST  32  // Reset pin, toggles on startup

//#define TFT_WR    4  // Write strobe control pin - must use a pin in the range 0-31
//#define TFT_RD    2  // Read strobe control pin

//#define TFT_D0   12  // Must use pins in the range 0-31 for the data bus
//#define TFT_D1   13  // so a single register write sets/clears all bits.
//#define TFT_D2   26  // Pins can be randomly assigned, this does not affect
//#define TFT_D3   25  // TFT screen update performance.
//#define TFT_D4   17
//#define TFT_D5   16
//#define TFT_D6   27
//#define TFT_D7   14

// ######       EDIT THE PINs BELOW TO SUIT YOUR STM32 SPI TFT SETUP        ######

// The TFT can be connected to SPI port 1 or 2
//#define TFT_SPI_PORT 1 // SPI port 1 maximum clock rate is 55MHz
//#define TFT_MOSI PA7
//#define TFT_MISO PA6
//#define TFT_SCLK PA5

//#define TFT_SPI_PORT 2 // SPI port 2 maximum clock rate is 27MHz
//#define TFT_MOSI PB15
//#define TFT_MISO PB14
//#define TFT_SCLK PB13

// Can use Ardiuno pin references, arbitrary allocation, TFT_eSPI controls chip select
//#define TFT_CS   D5 // Chip select control pin to TFT CS
//#define TFT_DC   D6 // Data Command control pin to TFT DC (may be labelled RS = Register Select)
//#define TFT_RST  D7 // Reset pin to TFT RST (or RESET)
// OR alternatively, we can use STM32 port reference names PXnn
//#define TFT_CS   PE11 // Nucleo-F767ZI equivalent of D5
//#define TFT_DC   PE9  // Nucleo-F767ZI equivalent of D6
//#define TFT_RST  PF13 // Nucleo-F767ZI equivalent of D7

//#define TFT_RST  -1   // Set TFT_RST to -1 if the display RESET is connected to processor reset
                        // Use an Arduino pin for initial testing as connecting to processor reset
                        // may not work (pulse too short at power up?)

// ##################################################################################
//
// Section 3. Define the fonts that are to be used here
//
// ##################################################################################

// Comment out the #defines below with // to stop that font being loaded
// The ESP8366 and ESP32 have plenty of memory so commenting out fonts is not
// normally necessary. If all fonts are loaded the extra FLASH space required is
// about 17Kbytes. To save FLASH space only enable the fonts you need!

#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
//#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT
#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts

// Comment out the #define below to stop the SPIFFS filing system and smooth font code being loaded
// this will save ~20kbytes of FLASH
#define SMOOTH_FONT


// ##################################################################################
//
// Section 4. Other options
//
// ##################################################################################

// Define the SPI clock frequency, this affects the graphics rendering speed. Too
// fast and the TFT driver will not keep up and display corruption appears.
// With an ILI9341 display 40MHz works OK, 80MHz sometimes fails
// With a ST7735 display more than 27MHz may not work (spurious pixels and lines)
// With an ILI9163 display 27 MHz works OK.

// #define SPI_FREQUENCY   1000000
// #define SPI_FREQUENCY   5000000
//#define SPI_FREQUENCY  10000000
//#define SPI_FREQUENCY  20000000
//#define SPI_FREQUENCY  27000000
//#define SPI_FREQUENCY  40000000
#define SPI_FREQUENCY  55000000 // STM32 SPI1 only (SPI2 maximum is 27MHz)
//#define SPI_FREQUENCY  65000000
 //#define SPI_FREQUENCY  80000000

// Optional reduced SPI frequency for reading TFT
#define SPI_READ_FREQUENCY  20000000

// The XPT2046 requires a lower SPI clock rate of 2.5MHz so we define that here:
 #define SPI_TOUCH_FREQUENCY  2500000

// The ESP32 has 2 free SPI ports i.e. VSPI and HSPI, the VSPI is the default.
// If the VSPI port is in use and pins are not accessible (e.g. TTGO T-Beam)
// then uncomment the following line:
//#define USE_HSPI_PORT

// Comment out the following #define if "SPI Transactions" do not need to be
// supported. When commented out the code size will be smaller and sketches will
// run slightly faster, so leave it commented out unless you need it!

// Transaction support is needed to work with SD library but not needed with TFT_SdFat
// Transaction support is required if other SPI devices are connected.

// Transactions are automatically enabled by the library for an ESP32 (to use HAL mutex)
// so changing it here has no effect

// #define SUPPORT_TRANSACTIONS

Hier die Displayansteuerung

#define TFT_MOSI 13 // In some display driver board, it might be written as "SDA" and so on.
#define TFT_SCLK 14
#define TFT_CS   15  // Chip select control pin
#define TFT_DC   2  // Data Command control pin
#define TFT_RST  12  // Reset pin (could connect to Arduino RESET pin)
#define TFT_BL   21  // LED back-light

Die KI muss noch viel suchen, lernen.

Noch was, für beide 3,5" Displays, einer hat Ili9488, der zweiter ST Treiber, habe auch die passende Daten

Entweder @matze1312 stellt noch die erforderlichen Informationen über seine Hardware bereit oder der TO geht selbst genau nach der PDF-Beschreibung vor, die offensichtlich schon vorliegt.

Das Abarbeiten einer aus dem Chinesischen ins Englische übersetzten Anleitung kann allerdings selbst für erfahrene Entwickler eine kleine Herausforderung sein.

Wie auch immer, die Hauptursache für seine Probleme sind fehlende Grundkenntnisse im Umgang mit der Materie.

Ist ein wenig wie bei Fahrschulanfängern, die gleich als allererstes alleine zu Hause mit einem Schwerlasttransporter mit Auflieger rückwärts in eine schmale Einfahrt fahren wollen ...

Deshalb mein Vorschlag:

a) Informationen liefern
b) Mit kleinen, einfachen Aufgaben anfangen (hello world) und sich Stück für Stück voran arbeiten

Das ist ein programm und die wichtigen daten von einen Bambulab 3D drucker extern nochmal zu sehen

Ich habe jetzt nochmal meinen Thread aktualisiert und hoffe es ist jetzt besser zu verstehen

Du hast ja nun reichlich Hilfen und Informationen bekommen. Funktioniert es jetzt, oder warum reagierst du nicht auf die zahlreichen Hilfestellungen ?