Sterowanie podświetleniem i obrót ekranu to podstawowe operacje związane z wyświetlaczem, które mają bezpośredni wpływ na działanie systemu w projektach opartych na mikrokontrolerach STM32. Są one niezależne od logiki aplikacji, ale ściśle powiązane z konfiguracją sprzętową i możliwościami środowiska graficznego.
W tym artykule wyjaśniamy, w jaki sposób moduły wyświetlaczy Riverdi STM32 realizują sterowanie podświetleniem oparte na PWM przy użyciu TIM15 i dedykowanego sterownika diod LED, a także jak różni się obrót ekranu w projektach LVGL i TouchGFX. Skupiamy się na praktycznych szczegółach implementacji i rozdzieleniu architektury modułu.
Sterowanie podświetleniem w wyświetlaczach Riverdi STM32
Sterowanie podświetleniem to jedna z podstawowych czynności podczas pracy z wyświetlaczami wbudowanymi. W przeciwieństwie do renderowania grafiki czy obsługi dotykowej, sterowanie podświetleniem jest niezależne od frameworka GUI i nie zależy od tego, czy aplikacja korzysta z LVGL, TouchGFX czy innego stosu graficznego.
W modułach wyświetlaczy Riverdi opartych na układach STM32 jasność podświetlenia jest regulowana za pomocą sprzętowego sygnału PWM, generowanego przez timer STM32.
Obsługiwane moduły Riverdi STM32
Metoda opisana w tym artykule dotyczy modułów wyświetlaczy Riverdi STM32, takich jak:
- RVT121
- RVT101
- RVT70
- RVT50
Tę samą zasadę można zastosować na innych platformach Riverdi STM32, które mają wejście do podświetlenia sterowane sygnałem PWM.
Zasada działania regulacji podświetlenia
W modułach wyświetlaczy Riverdi opartych na układach STM32 mikrokontroler nie steruje bezpośrednio podświetleniem LED. Zamiast tego STM32 generuje sygnał sterujący PWM, który jest przekazywany do specjalnego sterownika podświetlenia LED.
Sterownik podświetlenia to źródło prądu stałego, zaprojektowane do regulacji prądu płynącego przez łańcuchy diod LED. Sygnał PWM nie moduluje bezpośrednio napięcia diod LED. Zamiast tego steruje on efektywnym cyklem pracy sterownika, co pozwala na zmianę średniego prądu diod LED w zakresie od 0% do 100% jego wartości nominalnej.
Architekturę można podsumować w następujący sposób:
- Timer STM32 (np. TIM15) generuje sygnał PWM.
- Sygnał PWM jest podawany na wejście sterownika podświetlenia.
- Sterownik podświetlenia reguluje prąd diod LED.
- Cykl pracy sygnału PWM decyduje o rzeczywistej jasności.
To znaczy:
- Częstotliwość PWM zależy od ustawień timera
- Jasność jest proporcjonalna do cyklu pracy PWM.
- Prąd diody LED jest zawsze regulowany przez sterownik, a nie przez wejście GPIO MCU.
Wyższy cykl pracy → wyższy średni prąd diody LED → wyższa jasność wyświetlacza
Niższy cykl pracy → niższy średni prąd diody LED → słabsze podświetlenie wyświetlacza
Ponieważ diody LED są zasilane przez stabilizowane źródło prądu:
- regulacja jasności jest liniowa i stabilna,
- Żywotność diod LED jest zabezpieczona,
- zachowanie termiczne jest przewidywalne,
- Wydajność pozostaje wysoka w całym zakresie pracy.
Takie podejście zapewnia:
- płynna regulacja jasności,
- o niskim poborze mocy,
- prawidłowa regulacja natężenia prądu w podświetleniu LED,
- całkowita niezależność sprzętowa od frameworka GUI.
Wymagania sprzętowe i programowe
Zanim dostosujesz poziom podświetlenia, upewnij się, że:
- wyświetlacz jest prawidłowo podłączony do modułu STM32,
- płytka jest podłączona do komputera za pomocą ST-Link,
- Projekt został stworzony przy użyciu obsługiwanej szablonu oprogramowania (LVGL lub TouchGFX).
Sterowanie podświetleniem nie wymaga żadnych zmian w konfiguracji środowiska GUI.
Timer służący do sterowania podświetleniem
W modułach wyświetlaczy Riverdi STM32 podświetlenie steruje się za pomocą:
- TIM15 (zarówno w infrastrukturze U5, jak i H7)
- Sprzętowe wyjście PWM
- Kanał 1
Konfigurację PWM znajdziesz w pliku projektu tim.c, w funkcji MX_TIM15_Init().
Przykład konfiguracji PWM
Kanał PWM konfiguruje się za pomocą standardowych struktur HAL dla STM32:
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 998;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_1) !=
HAL_OK)
{
Error_Handler();
}Najważniejszym parametrem jest tutaj sConfigOC.Pulse.
Zakres jasności i jego znaczenie
Jasność podświetlenia jest regulowana za pomocą cyklu pracy PWM:
- 0 → podświetlenie wyłączone
- 998 → maksymalna jasność
Każda wartość z przedziału od 0 do 998 odpowiada proporcjonalnemu poziomowi jasności.
Regulacja jasności w czasie pracy
Oprócz konfiguracji statycznej poziom podświetlenia można też zmienić w czasie wykonania programu, zapisując dane bezpośrednio w rejestrze timera:
TIM15->CCR1 = twoja_nowa_wartość_impulsu;
Dzięki temu można:
- dynamiczna regulacja jasności,
- regulacja jasności na podstawie światła otoczenia,
- tryb oszczędzania energii,
- płynne efekty pojawiania się i zanikania.
Nie trzeba ponownie inicjować wyświetlacza.
Obrót ekranu na wyświetlaczach STM32
W przeciwieństwie do sterowania podświetleniem, obrót ekranu nie jest w przypadku STM32 operacją czysto sprzętową.
Układ peryferyjny kontrolera wyświetlacza LCD TFT (LTDC) nie obsługuje obracania obrazu, co oznacza, że obrót musi być obsługiwany na poziomie na poziomie frameworka graficznego.
W zależności od wybranego frameworka GUI sposób implementacji znacznie się różni.
W tej sekcji wyjaśniono oba podejścia stosowane w wyświetlaczach Riverdi STM32:
- Obrót oparty na LVGL
- Obrót oparty na TouchGFX
Obrót ekranu za pomocą LVGL
Podczas korzystania z modułów wyświetlaczy Riverdi STM32 z panelami RGB układ peryferyjny STM32 LTDC przesyła piksele z pamięci linia po linii. Ponieważ LTDC nie obsługuje rotacji sprzętowej, jedynym niezawodnym sposobem na obrócenie obrazu jest zrobienie tego programowo, zanim piksele dotrą do bufora ramki LTDC.
LVGL obsługuje obrót wyświetlacza za pomocą:
lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_xxx);
, gdzie xxx może wynosić 0, 90, 180 lub 270.
To wywołanie aktualizuje jednak wewnętrzny układ współrzędnych LVGL i sposób obsługi układu graficznego – nie powoduje ono automatycznego obracania danych pikseli w potokach RGB opartych na LTDC. Z tego powodu obracanie pikseli trzeba załatwić w ramach flush callback w LVGL.
Gdzie w procesie LVGL mieści się rotacja
W tej konfiguracji:
- LVGL renderuje małe „kafelki” do bufora roboczego (px_map) w trybie renderowania PARTIAL.
- Funkcja flush callback (disp_flush) zapisuje wyrenderowane kafelki do bufora ramki LTDC.
- Jeśli obrócenie jest włączone, flush callback obraca kafelek przed zapisaniem go do bufora ramki.
- Współrzędne dotykowe pozostają niezmienne, bo LVGL zna aktualny kąt obrotu wyświetlacza.
Inicjalizacja LVGL (częściowe renderowanie + obrót)
Wyświetlacz jest tworzony i konfigurowany w pliku lvgl_port_display.c:
void lvgl_display_init(void)
{
disp = lv_display_create(MY_DISP_HOR_RES, MY_DISP_VER_RES);
__attribute__((section(".my_ram_d2_data")))
static uint8_t buf1[288 * 1024];
lv_display_set_buffers(disp, (void *)buf1, NULL, sizeof(buf1),
LV_DISPLAY_RENDER_MODE_PARTIAL);
/* Ustaw żądany kąt obrotu */
lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_90);
/* Zarejestruj flush callback */
lv_display_set_flush_cb(disp, disp_flush);
}
Wywołanie flush callback (zapis danych z oprogramowania do bufora ramki LTDC)
Poniżej znajdziesz flush callback używany w wyświetlaczach Riverdi STM32 z LTDC.
Obsługuje obrót o:
- Zmiana obszaru docelowego za pomocą funkcji lv_display_rotate_area() oraz
- Obrót danych pikseli za pomocą funkcji `lv_draw_sw_rotate()` przed zapisaniem ich do bufora ramki `
`.
static void disp_flush(lv_display_t * display,
const lv_area_t * area,
uint8_t * px_map)
{
lv_color_format_t cf = lv_display_get_color_format(display);
uint32_t px_size = lv_color_format_get_size(cf); /* RGB565 = 2 bajty */
/* Oblicz powierzchnię docelową po obrocie */
lv_area_t rot_area = *area;
lv_display_rotate_area(display, &rot_area);
int32_t src_w = lv_area_get_width(area);
int32_t src_h = lv_area_get_height(area);
uint32_t src_stride = lv_draw_buf_width_to_stride(src_w, cf);
uint32_t fb_stride = lv_draw_buf_width_to_stride(MY_DISP_HOR_RES, cf);
/* Adres bufora ramki LTDC */
uint8_t * fb = (uint8_t *)hltdc.LayerCfg[0].FBStartAdress;
fb += (rot_area.y1 * fb_stride) + (rot_area.x1 * px_size);
/* Obsługa pamięci podręcznej (wymagana, gdy bufor ramki znajduje się w zewnętrznej pamięci SDRAM) */
SCB_CleanInvalidateDCache();
lv_display_rotation_t r = lv_display_get_rotation(display);
if(r == LV_DISPLAY_ROTATION_0) {
/* Szybka ścieżka: bez obracania */
for(int32_t y = 0; y < src_h; y++) {
lv_memcpy(fb, px_map, src_stride);
px_map += src_stride;
fb += fb_stride;
}
} else {
/* Obróć wyrenderowaną płytkę bezpośrednio w buforze ramki */
lv_draw_sw_rotate(px_map, fb,
src_w, src_h,
src_stride, fb_stride,
r, cf);
}
/* Poinformuj LVGL, że operacja flush została zakończona */
lv_display_flush_ready(display);
}Wynik
Przy takim podejściu:
- obraz jest fizycznie obracany przed wysłaniem sygnału LTDC,
- Układ i renderowanie LVGL pozostają spójne,
- współrzędne dotykowe pozostają wyrównane względem obróconego interfejsu użytkownika,
- nie trzeba wprowadzać żadnych zmian w konfiguracji taktowania LTDC.
Obrót ekranu na STM32 przy użyciu TouchGFX
W przeciwieństwie do LVGL, TouchGFX obsługuje obrót ekranu zarówno na poziomie frameworka, jak i konfiguracji. W większości projektów wyświetlaczy Riverdi opartych na układach STM32 można włączyć obrót bez wprowadzania zmian w sterownikach niskopoziomowych ani w kodzie obsługującym bufor ramki.
Dzięki temu TouchGFX jest szczególnie przydatny, gdy:
- orientacja wyświetlacza jest znana już na etapie projektowania,
- rotacji nie trzeba zmieniać dynamicznie w czasie wykonania programu,
- Preferowane jest szybkie i łatwe w utrzymaniu podejście oparte na konfiguracji.
Koncepcja obracania w TouchGFX
TouchGFX abstrakcyjnie przedstawia potok wyświetlania i zarządza:
- układ bufora ramki,
- orientacja renderowania,
- przekształcenia współrzędnych,
- mapowanie gestów dotykowych.
W rezultacie:
- w ścieżce flush LTDC nie trzeba ręcznie obracać pikseli,
- nie trzeba w żaden sposób modyfikować bufora ramki na zamówienie,
- Obrót jest stosowany spójnie zarówno podczas renderowania, jak i przy obsłudze dotykowej.
Włączanie obrótu ekranu w programie TouchGFX Designer
Obrót ekranu konfiguruje się bezpośrednio w programie TouchGFX Designer.
Dokładna nazwa może się nieco różnić w zależności od wersji TouchGFX, ale przebieg operacji „
” jest zawsze taki sam.
Krok 1 — Otwórz ustawienia wyświetlacza
W programie TouchGFX Designer:
- Otwórz swój projekt.
- Przejdź do sekcji „Wyświetlacz / Płytka / Konfiguracja aplikacji ”.
- Znajdź ustawienie „Orientacja wyświetlacza ” lub „Obrót ekranu ”.
Podsumowanie
W modułach Riverdi STM32 jasność podświetlenia jest sterowana za pomocą sprzętowego sygnału PWM generowanego przez TIM15 i regulowanego przez sterownik diod LED o stałym natężeniu prądu. Cykl pracy określa jasność niezależnie od środowiska GUI, co zapewnia stabilne i przewidywalne działanie.
Obrót ekranu nie jest obsługiwany przez sprzęt LTDC i musi być realizowany na poziomie warstwy graficznej. W LVGL obrót wymaga programowej transformacji pikseli w procedurze flush callback. W TouchGFX obrót konfiguruje się na poziomie frameworka bez modyfikowania sterowników niskopoziomowych wyświetlacza
Oddzielenie sterowania na poziomie sprzętowym od zadań warstwy graficznej zapewnia przejrzystą architekturę i niezawodność systemów wyświetlaczy opartych na mikrokontrolerach STM32.
ODKRYJ NASZĄ
Whitepaper
Osiągnij idealną interakcję użytkownika z wyświetlaczem dzięki odpowiedniemu czujnikowi Touch Sensor IC. Czy kiedykolwiek zmagałeś się z problemami związanymi z fantomowymi dotknięciami lub certyfikacją? Rozwiń swoje prace B+R jak profesjonalista dzięki naszemu Whitepaperowi!
Przejdź do naszego katalogu produktów i zobacz, jak możesz oszczędzać dzięki jakości, nie na jakości.
