So steuern Sie ein TFT-Display über die RGB-Schnittstelle

Hintergrund

Um ein TFT-Display über eine RGB-Schnittstelle anzusteuern, müssen parallele R-, G- und B-Datensignale sowie HSYNC- (Horizontal-Sync) und VSYNC-Signale (Vertikal-Sync) an einen Mikrocontroller oder einen dedizierten Display-Controller gesendet werden. Das Hostsystem sendet Pixeldaten, und die Sync-Signale teilen dem Display mit, wann eine neue Zeile oder ein neues Bild gestartet werden soll. Dieser Prozess kann asynchron mit einem Frame-Puffer oder durch kontinuierliche Datenübertragung erfolgen.

Um zu veranschaulichen, wie die Ansteuerung eines TFT-Displays mit RGB-Schnittstelle implementiert wird, verwenden wir das 10,1-Zoll-TFT-LCD TM101DDHG06 von Tianman und die i.MX RT1050 MCU mit Arm Cortex-M7-Kern, 528 MHz Maximalfrequenz und 512 kB SRAM von NXP Semiconductor.

Teil 1 — Theorie: Ansteuerung eines TFTs über die RGB-Schnittstelle

1.1 Einführung in die RGB-Schnittstelle

Die RGB-Schnittstelle ist eine gängige Methode, einen Mikroprozessor (MCU) mit einem TFT-LCD zu verbinden. Es handelt sich um eine parallele Schnittstelle, d. h. sie überträgt viele Daten gleichzeitig und ist daher schnell genug für hochauflösende Displays. Die wichtigsten Signale sind:

Pixeltakt (PCLK) : Dies ist der Herzschlag der Schnittstelle. Bei jedem Taktzyklus werden die Daten eines Pixels an das Display gesendet.

Horizontale Synchronisierung (HSYNC) : Dieses Signal teilt dem Display mit, wann eine neue Pixelzeile beginnt.

Vertikale Synchronisierung (VSYNC) : Dieses Signal teilt dem Display mit, wann ein neues Bild (ein voller Pixelbildschirm) beginnt.

Datenfreigabe (DE) : Dieses Signal zeigt an, wann die Pixeldaten auf den Datenleitungen gültig sind.

Rote, grüne und blaue Datenleitungen (R, G, B) : Dies sind die eigentlichen Datenleitungen, die die Farbinformationen für jedes Pixel übertragen. Eine 24-Bit-RGB-Schnittstelle verfügt beispielsweise über 8 Leitungen für Rot, 8 für Grün und 8 für Blau.

1.2 Was das TM101DDHG06-Panel erwartet (Schlüsselfakten)

10,1" TFT , Auflösung 1024 × 3 (RGB) × 600, TTL / RGB888-Parallelschnittstelle. Es verfügt über folgende Pins: R0..R7, G0..G7, B0..B7, DCLK (Pixeltakt), HS (Hsync), VS (Vsync), DE (Datenfreigabe) sowie Strompins (VDD, AVDD, VGH/VGL), RESET und Steuerpins (SHLR, UPDN, DITHB). Die vollständige Pinbelegung und die erforderlichen Schienenspannungen finden Sie im Datenblatt.

Wichtige elektrische Werte: VDD = 3,3 V (typisch 3,3 V), AVDD ≈ 11 V, VGH ≈ +22 V, VGL ≈ -7 V. Die Hintergrundbeleuchtungs-LED benötigt ~9,6 V bei ~224 mA (LED-Anschluss des Panels). Beachten Sie die empfohlene Ein-/Ausschaltreihenfolge im Datenblatt, um Panelschäden zu vermeiden.

1.3 Welche Fähigkeiten muss die MCU (i.MX RT1052) bieten

Ein dedizierter LCD-Controller: Dies ist ein spezielles Peripheriegerät auf der MCU, das das Timing (Erzeugung von Pixeltakt, HSYNC, VSYNC, DE) und die Datenübertragung zum LCD übernimmt. Beim i.MX RT1052 wird dies als eLCDIF (Enhanced Liquid Crystal Display Interface) bezeichnet. Es ist entscheidend, da es die CPU von der intensiven Aufgabe der ständigen Aktualisierung des Displays entlastet.

Ausreichend RAM für einen Framebuffer: Ein Framebuffer ist ein RAM-Bereich, der die Farbdaten für jedes Pixel auf dem Bildschirm speichert. Der eLCDIF DMA der MCU liest aus diesem Framebuffer, um zu wissen, was angezeigt werden soll. Die Größe des Framebuffers hängt von der Auflösung und Farbtiefe des Displays ab. Für unser 10,1-Zoll-Display mit einer Auflösung von 1024 x 600 und 24-Bit-Farbtiefe (3 Bytes pro Pixel) wäre die Framebuffer-Größe:

1024 Pixel * 600 Pixel * 3 Bytes/Pixel = 1.843.200 Bytes oder etwa 1,84 MB. Der i.MX RT1052 verfügt über 512 KB On-Chip-RAM, daher müssen wir für den Framebuffer externes SDRAM verwenden.

Ausreichende E/A-Pins: Viele MCU-Pins sind gemultiplext. Wir müssen die eLCDIF-Signale mit der richtigen IOMUX-Konfiguration den physischen Pins zuordnen.

Ein schneller Kern: Der LCD-Controller übernimmt die Displayaktualisierung. Er benötigt einen Pixeltakt, der von einer System-PLL oder einer dedizierten LCD-PLL abgeleitet wird. Bei 1024×600-Panels hängen typische Pixeltakte von den gewählten Timings ab (oft ~33–70 MHz, abhängig von H/V-Veranda und Blanking). Die MCU muss diesen Takt bereitstellen und routen. Der ARM Cortex-M7-Kern im i.MX RT1052 ist schnell genug, um die Anwendungslogik auszuführen und den Framebuffer für die Anzeige dynamischer Inhalte zu aktualisieren.

Stromschienen & LED-Treiber: Die MCU-Platine darf nicht versuchen, AVDD/VGH/VGL zu erzeugen. Üblicherweise wird eine dedizierte Stromversorgungslösung (Aufwärtswandler) verwendet oder die vom Panel-Hersteller empfohlenen Stromversorgungsschaltungen verwendet. Die MCU steuert RESET und optional die Aktivierung der Hintergrundbeleuchtung über einen GPIO und einen geeigneten LED-Treiber/Transistor.

1.4 Allgemeiner High-Level-Flow zum Ansteuern eines RGB-TFTs

Hardwarevorbereitung

• Stellen Sie die erforderlichen Paneelschienen (VDD, AVDD, VGH, VGL) in der richtigen Reihenfolge bereit.
• Verbinden Sie die LED-Schienen für die Hintergrundbeleuchtung mit einem geeigneten LED-Treiber oder Widerstand+MOSFET.
• Ordnen Sie eLCDIF-Signale (DCLK, HSYNC, VSYNC, DE und Datenleitungen) den IOMUX-Pins der MCU zu. Stellen Sie die Signalintegrität für den Parallelbus sicher (kurze Leitungen, gute Erdung).
• Sorgen Sie für eine Pegelanpassung (die TTL-Pegel des Panels liegen zwischen 0 und VDD). Stellen Sie sicher, dass MCU IO 3,3 V-tolerant und angepasst ist.

Pin-/Taktkonfiguration

• Konfigurieren Sie IOMUX für die eLCDIF-Funktion auf den ausgewählten Pins.
• Konfigurieren Sie einen LCD-Pixeltakt (von PLL) mit der für Ihr Timing erforderlichen Frequenz.

Frame-Puffer-Zuweisung

• Reservieren Sie externen SDRAM-Speicherplatz für einen oder zwei Frame-Puffer (für eine flüssigere Anzeige wird Doppelpufferung empfohlen).
• Stellen Sie die Pufferausrichtung und die Cacheverwaltung sicher (wenn Caches vorhanden sind, leeren/ungültig machen Sie diese nach Bedarf, bevor eLCDIF den Puffer liest).

Initialisierung des LCD-Controllers

Der LCD-Controller (eLCDIF) der MCU muss mit Auflösung (1024×600), Pixelformat (RGB888), horizontalen/vertikalen Zeitparametern (aktive Pixel, vordere/hintere Veranda, Synchronisierungsimpulsbreiten) unter Verwendung von Werten aus dem Datenblatt des Panels programmiert werden.

Startanzeige

• Programmieren Sie eLCDIF, um den Puffer über DMA zu lesen und DOTCLK/HSYNC/VSYNC/DE automatisch zu generieren.
• Lösen Sie den Bedienfeld-RESET, wenden Sie die richtige Stromsequenz an und aktivieren Sie die Hintergrundbeleuchtung.

Grafik-Update

Verwenden Sie doppelte Pufferung: Schreiben Sie in den Back-Puffer, leeren Sie den Cache, wechseln Sie den Pufferzeiger zu eLCDIF und zeichnen Sie dann das nächste Bild.

1.5 Timing und DE vs. SYNC-Modi

Das Panel unterstützt den DE-Modus (MODE=H) oder den SYNC-Modus (MODE=L) gemäß dem MODE-Pin im Datenblatt. Der DE-Modus wird häufig verwendet: DE zeigt gültige Pixeldaten an, und HS/VS kann unbenutzt oder gebunden sein. Überprüfen Sie die Zeitdiagramme im Datenblatt und stellen Sie eLCDIF entsprechend ein.

Teil 2 — Praxisprojekt: Antrieb TM101DDHG06 mit i.MX RT1052

2.1 Annahmen und Voraussetzungen

• Ihnen steht ein i.MX RT1052-Entwicklungsboard (MIMXRT1050-EVK, Embedded Artists-Modul oder Custom-Board) mit externem SDRAM zur Verfügung.
• Sie verwenden das NXP MCUXpresso SDK und dessen eLCDIF-Beispiel (elcdif_rgb) als Ausgangspunkt. Das Beispiel implementiert Pufferzufuhr und Timings.
• Ein 50-poliger FPC-Anschluss/Adapter zum Verbinden des LCD mit dem EVK.

2.2 Hardware-Anschlüsse

Die Verbindung zwischen dem i.MX RT1052 EVK und dem LCD erfolgt wie folgt. Die genauen Pin-Positionen auf den Headern der Platine finden Sie im Benutzerhandbuch des EVK.

Panel-Signal	MCU-Signal (Beispiel)
R0..R7	LCD_DATA0..LCD_DATA7
G0..G7	LCD_DATA8..LCD_DATA15
B0..B7	LCD_DATA16..LCD_DATA23
DCLK	LCD_CLK (DOTCLK)
HSYNC	LCD_HSYNC
VSYNC	LCD_VSYNC
DE	LCD_DE
ZURÜCKSETZEN	GPIOx (Panel-Reset, aktiv niedrig)
MODUS	GPIOy (an H für DE-Modus oder L für SYNC binden)
SHLR / UPDN	GPIOs (wenn Sie Flip/Spiegelung benötigen)
LEDA / LEDK	Externer LED-Treiber + GPIO aktivieren

 

2.3 Leistungssequenzierung

Befolgen Sie die Reihenfolge im Datenblatt genau (dies ist eine komprimierte Checkliste – verwenden Sie die Schritttabelle im Datenblatt):

1. Beim Einschalten ist VDD (digital) stabil.
2. Aktivieren Sie AVDD (analog) und dann VGH/VGL (Gate-Treiber) der Reihe nach – verwenden Sie nach Bedarf Aufwärtswandler.
3. RESET loslassen (nachdem die Analog-/Gate-Schienen bereit sind).
4. Wenden Sie den Pixeltakt an und aktivieren Sie die MCU-Ausgangssignale.
5. Aktivieren Sie zuletzt die Hintergrundbeleuchtung (über den LED-Treiber).

Das Ausschalten erfolgt in umgekehrter Reihenfolge: Hintergrundbeleuchtung aus → Pixeltakt stoppen → RESET aktivieren → VGH/VGL entfernen → AVDD entfernen → VDD entfernen. Bei Nichtbeachtung der Reihenfolge kann das Panel beschädigt werden.

2.4 Software: MCUXpresso SDK-Ansatz

• Installieren Sie das MCUXpresso SDK für i.MX RT1052 und öffnen Sie das Beispiel elcdif_rgb . Dieses Beispiel demonstriert die eLCDIF-Initialisierung und grundlegendes Framebuffer-DMA.
• Konfigurieren:
  • Pixeltaktfrequenz und PLL.
  • eLCDIF-Parameter: Breite=1024, Höhe=600, Pixelformat RGB888.
  • Horizontale/vertikale Timing-Werte: Verwenden Sie die vom Panel empfohlenen Werte für Htotal, Hsync-Breite, Hfp/Hbp und Vsync/Porches aus der Timing-Tabelle im Datenblatt.
• Ordnen Sie zwei Frame-Puffer im externen SDRAM zu (Heap oder statisch). Richten Sie die Größe auf 32 Byte oder nach Bedarf aus.
• Implementieren Sie eine einfache Framebuffer-Füllfunktion, die Testmuster (Farbbalken) malt, um Verbindungen zu validieren.
• Starten Sie eLCDIF im Controller-Mastermodus, um den Frame-Puffer zu ziehen und DOTCLK/HS/VS zu generieren.
• Verwenden Sie für Updates die doppelte Pufferung: Bereiten Sie den Back-Puffer vor, und tauschen Sie dann den Zeiger aus (verwenden Sie die eLCDIF-API zum Aktualisieren des Frame-Pufferzeigers), um sicherzustellen, dass der Datencache geleert wird.

2.5 Code-Implementierung

Hier sind die wichtigsten Codeausschnitte und Erklärungen.

1. Pin-Muxing

Zunächst müssen wir die Pins der MCU für die Verwendung durch das eLCDIF-Peripheriegerät konfigurieren. Dies geschieht mit dem Modul IOMUXC .

#include "fsl_iomuxc.h"

Leere BOARD_InitLcdPins(leer)
{
// Konfigurieren Sie die Pins für die LCD-Datenleitungen, Takt- und Steuersignale.
// Dies ist nur ein konzeptionelles Beispiel. Die tatsächlichen Pin-Namen variieren je nach EVK.
IOMUXC_SetPinMux(IOMUXC_GPIO_B0_00_LCD_DATA00, 0U);
// ... für alle 24 Datenzeilen wiederholen ...
IOMUXC_SetPinMux(IOMUXC_GPIO_B1_03_LCD_CLK, 0U);
IOMUXC_SetPinMux(IOMUXC_GPIO_B1_04_LCD_HSYNC, 0U);
IOMUXC_SetPinMux(IOMUXC_GPIO_B1_05_LCD_VSYNC, 0U);
IOMUXC_SetPinMux(IOMUXC_GPIO_B1_06_LCD_ENABLE, 0U);
}

2. Taktkonfiguration

Als nächstes konfigurieren wir den Pixeltakt. Das Datenblatt des TM101DDHG06 gibt einen typischen Pixeltakt von 51,2 MHz an.

#include "fsl_clock.h"

void BOARD_InitLcdClocks(void)
{
// Konfigurieren Sie die PLL, die als Quelle für die LCD-Uhr dienen soll.
// Das Ziel sind 51,2 MHz.
clock_video_pll_config_t pll_config = {
.loopDivider = 42,
.postDivider = 3,
.Zähler = 0,
.Nenner = 0,
};
CLOCK_InitVideoPll(&pll_config);

// Stellen Sie den Taktteiler für das eLCDIF-Peripheriegerät ein.
CLOCK_SetMux(kCLOCK_LcdifPreMux, 2); // Benutze die Video-PLL
CLOCK_SetDiv(kCLOCK_LcdifPreDiv, 3);
}

3. eLCDIF-Initialisierung

Hier konfigurieren wir das eLCDIF mit den Timing-Parametern aus dem LCD-Datenblatt.

#include "fsl_elcdif.h"

#define APP_LCD_WIDTH 1024
#define APP_LCD_HEIGHT 600
#define APP_HSW 20
#define APP_HFP 140
#define APP_HBP 160
#define APP_VSW 3
#define APP_VFP 12
#define APP_VBP 20
#define APP_LCD_POL_FLAGS kELCDIF_DataEnableActiveHigh | kELCDIF_VsyncActiveLow | kELCDIF_HsyncActiveLow | kELCDIF_PixelClockActiveHigh

void APP_InitLcd(void)
{
elcdif_rgb_mode_config_t Konfiguration;

config.panelWidth = APP_LCD_WIDTH;
config.panelHeight = APP_LCD_HEIGHT;
config.hsw = APP_HSW;
config.hfp = APP_HFP;
config.hbp = APP_HBP;
config.vsw = APP_VSW;
config.vfp = APP_VFP;
config.vbp = APP_VBP;
config.polarityFlags = APP_LCD_POL_FLAGS;
config.pixelFormat = kELCDIF_PixelFormatRGB888;
config.dataBus = kELCDIF_DataBus24Bit;

// Richten Sie den LCD-Controller auf den Framebuffer
config.bufferAddr = (uint32_t)s_frameBuffer;

ELCDIF_RgbModeInit(ELCDIF, &config);
}

4. Framebuffer

Wir deklarieren den Framebuffer im externen SDRAM. Das Linker-Skript muss so konfiguriert werden, dass dieses Array im SDRAM-Bereich platziert wird.

// Platziere den Framebuffer im SDRAM
AT_NONCACHEABLE_SECTION_ALIGN(uint32_t s_frameBuffer[APP_LCD_HEIGHT][APP_LCD_WIDTH], 64);

5. Zeichnen eines einfachen Musters

Hier ist eine Funktion zum Füllen des Framebuffers mit einer durchgehend blauen Farbe.

void APP_FillFrameBuffer(void)
{
uint32_t color = 0x000000FF; // Blau im RGB888-Format

für (int y = 0; y < APP_LCD_HEIGHT; y++)
{
für (int x = 0; x < APP_LCD_WIDTH; x++)
{
s_frameBuffer[y][x] = Farbe;
}
}
}

6. Die Hauptfunktion

Lassen Sie uns abschließend alles zusammenfassen.

int main(void)
{
// Initialisiere die Hardware der Karte
BOARD_InitPins();
BOARD_InitLcdPins();
BOARD_InitLcdClocks();
BOARD_InitSdram(); // Initialisiere das externe SDRAM

// Initialisiere den LCD-Controller
APP_InitLcd();

// Füllen Sie den Framebuffer mit einer Farbe
APP_FillFrameBuffer();

// Starten Sie den LCD-Controller
ELCDIF_RgbModeStart(ELCDIF);

während (1)
{
// Hier kommt Ihr Anwendungscode hin.
// Sie können den Framebuffer aktualisieren, um zu ändern, was auf dem Bildschirm angezeigt wird.
}
}

2.6 Tipps zum Debuggen und häufige Fehler

• Kein Bild / Müll : Überprüfen Sie den DE- und SYNC-Modus (MODE-Pin) und stellen Sie sicher, dass Sie das richtige Timing und Pixelformat haben.
• Teilspalten/verschobenes Bild : Überprüfen Sie die DCLK-Polarität (Panel verriegelt an fallender/steigender Flanke – das Datenblatt gibt die Verriegelungsflanke an) und SHLR/UPDN für die Scanrichtung.
• Flackern/instabil : falsche Pixeltaktfrequenz oder fehlende Stabilisierung der analogen Schienen (AVDD/VGH/VGL).
• Beschädigte Farben : Byte-Reihenfolge stimmt nicht überein (MCU-Puffer speichert BGR vs. Panel erwartet RGB) – Kanäle bei Bedarf tauschen.
• Zu langsame Updates : Stellen Sie sicher, dass DMA vom SDRAM verwendet wird. Verwenden Sie bei Bedarf aktiv die PXP/2D-Engine zum Skalieren/Rotieren.

Ein letztes Wort

Die Ansteuerung eines Displays ist ein komplexes Thema, und es gibt noch viel mehr zu lernen, z. B. die Verwendung von DMA zur effizienteren Aktualisierung des Framebuffers, die Implementierung von Grafikbibliotheken und den Umgang mit Touchscreens. Mit diesen Grundlagen sollten Sie jedoch gut gerüstet sein, um Ihre Reise in die Entwicklung eingebetteter Grafiken zu beginnen!

Wenn Sie mehr über TFT-Displaylösungen erfahren möchten, kontaktieren Sie uns bitte.