Jak uruchomić LVGL na wyświetlaczu Riverdi EVE
Uruchamianie nowoczesnej GUI na mikrokontrolerze zazwyczaj wiąże się z koniecznością radzenia sobie z buforami ramki, ograniczeniami pamięci i kompromisami w zakresie wydajności.
Dzięki rozwiązaniu EVE od naszego partnera Bridgetek renderowanie grafiki HMI w wysokiej rozdzielczości, obsługa dźwięku i sterowanie dotykowe przechodzi w ręce procesora graficznego (GPU). Jednocześnie LVGL, również partner Riverdi, zapewnia elastyczny i powszechnie stosowany framework interfejsu użytkownika.
Efekt: dzięki takiej konfiguracji możesz tworzyć złożone interfejsy bez wykorzystywania pełnej mocy MCU, a niedrogie procesory mogą obsługiwać zaawansowane, profesjonalnie wyglądające kolorowe wyświetlacze przy minimalnym obciążeniu
W tym poradniku wyjaśniamy, jak uruchomić LVGL na inteligentnym wyświetlaczu Riverdi EVE4 przy użyciu płytki ewaluacyjnej Riverdi opartej na układzie STM32F4.
W tym przykładzie wykorzystano 7-calowy wyświetlacz Riverdi RVT70HSBNWC00-B podłączony przez interfejs SPI za pośrednictwem interfejsu RiBUS.
Celem tego samouczka jest pokazanie, jak:
- zainicjuj LVGL na MCU hosta
- połącz LVGL z silnikiem graficznym EVE
- renderować widżety LVGL na wyświetlaczu
- włącz obsługę dotykową
W przeciwieństwie do tradycyjnych wyświetlaczy wbudowanych, architektura EVE nie wymaga, żeby MCU hosta renderował cały bufor ramki. Zamiast tego MCU wysyła polecenia rysowania do procesora graficznego EVE, który renderuje ostateczny obraz.
To znacznie zmniejsza zużycie pamięci i obciążenie procesora MCU.
Użyty sprzęt
W tym poradniku używamy EVE4 (BT817Q). Zgodnie z dokumentacją LVGL powinno to działać również na innych wersjach EVE, ale nie zostało to jeszcze przetestowane.
W tym samouczku wykorzystano następujące elementy sprzętowe.
Riverdi RVT70HSBNWC00-B
- 7-calowy inteligentny wyświetlacz EVE4
- Rozdzielczość: 1280 × 600
- Wbudowany procesor graficzny BT817Q
- Ekran pojemnościowy PCAP
Płytka ewaluacyjna Riverdi
- Mikrokontroler STM32F4
ST-Link
- służy do programowania i debugowania
Płaski kabel RiBUS
- służy do komunikacji SPI między hostem a modułem EVE
Kable micro-USB
- jeden dla ST-Link
- jeden do zasilania płytki ewaluacyjnej
Wymagania programowe
Zanim zaczniesz proces integracji, musisz przygotować kilka komponentów oprogramowania. Projekt został stworzony w środowisku programistycznym STM32CubeIDE, a framework interfejsu graficznego zapewnia LVGL. Komunikacja z silnikiem graficznym EVE odbywa się za pośrednictwem bibliotek wsparcia Riverdi EVE, które realizują interfejs niskopoziomowy między MCU hosta a procesorem graficznym BT817.
W tej konfiguracji LVGL nie renderuje pikseli bezpośrednio do bufora ramki. Zamiast tego operacje rysowania LVGL są przekształcane na polecenia EVE, które są wysyłane do procesora graficznego przez interfejs SPI. Urządzenie EVE następnie wykonuje te polecenia, żeby wyświetlić ostateczną klatkę na wyświetlaczu.
Potrzebne są następujące narzędzia:
STM32CubeIDE (lub inne środowisko IDE)
- środowisko programistyczne dla projektów STM32
- służy do konfiguracji urządzeń peryferyjnych, kompilacji projektu i programowania MCU
Biblioteka graficzna LVGL
- wbudowany framework GUI służący do tworzenia interfejsu użytkownika
- oferuje widżety, system układów oraz obsługę zdarzeń
Biblioteki pomocnicze Riverdi EVE
- zapewnia komunikację na niskim poziomie z procesorem graficznym EVE]
- obsługuje transakcje SPI i dostęp do bufora FIFO poleceń
Git
- służy do pobierania repozytoriów i przykładowych projektów
Żeby znaleźć ten projekt, zajrzyj na GitHub Riverdi i poszukaj repozytorium EVE-LVGL.
Zrozumienie architektury renderowania w EVE
Kluczową różnicą między wyświetlaczami EVE a tradycyjnymi wyświetlaczami wbudowanymi jest sposób generowania ramek. W większości systemów wbudowanych mikrokontroler wykonuje renderowanie pikseli do bufora ramki, z którego kontroler wyświetlacza na bieżąco odczytuje dane w celu odświeżania ekranu
Urządzenia EVE działają na innej zasadzie. Zamiast wysyłać bufor ramki, MCU host wysyła polecenia rysowania do procesora graficznego. Polecenia te określają, co ma się pojawić na ekranie, a silnik graficzny EVE sam generuje ostateczne piksele.
To znacznie zmniejsza zużycie pamięci i wymagania dotyczące przepustowości w MCU.
Renderowana ramka jest definiowana przez strukturę zwaną display list. Display list to sekwencja poleceń dla procesora graficznego, które są wykonywane w każdej ramce w celu wygenerowania ostatecznego obrazu.
Uproszczony potok wyświetlania wygląda więc tak:
MCU → polecenia rysowania → procesor graficzny EVE → panel LCD
To właśnie dzięki tej architekturze opartej na poleceniach skomplikowane interfejsy graficzne mogą działać na stosunkowo niewielkich mikrokontrolerach.
Najważniejsze bloki pamięci EVE
Wewnętrznie procesor graficzny EVE korzysta z kilku obszarów pamięci do przetwarzania poleceń graficznych.
RAM_DL
- zapisuje display list używaną do renderowania bieżącej ramki
RAM_G
- pamięć graficzna ogólnego przeznaczenia, używana do przechowywania obrazów, czcionek i innych zasobów graficznych
Command FIFO
- bufor używany przez koprocesor do odbierania poleceń z MCU
MCU hosta zapisuje polecenia do bufora FIFO poleceń. Koprocesor EVE interpretuje te polecenia i tworzy display list przechowywaną w pamięci RAM_DL. Podczas cyklu odświeżania ekranu procesor graficzny (GPU) wykonuje display list i generuje ostateczną ramkę.
Jak LVGL wpisuje się w proces
Gdy LVGL działa z tradycyjnymi wyświetlaczami, wykonuje renderowanie pikseli do bufora ramki w pamięci MCU. W przypadku wyświetlaczy EVE proces ten przebiega inaczej.
Operacje rysowania LVGL są przekształcane na polecenia EVE dla procesora graficznego, które są wysyłane do urządzenia przez interfejs SPI. Następnie procesor graficzny tworzy display list i wykonuje renderowanie ramki wewnętrznie.
Oto jak wygląda wynikowy przebieg:
Dzięki temu LVGL może obsługiwać złożone interfejsy użytkownika, a jednocześnie zużycie pamięci przez MCU pozostaje na bardzo niskim poziomie.
Tworzenie projektu STM32
Kolejnym krokiem jest przygotowanie projektu rozwojowego dla płytki ewaluacyjnej Riverdi. MCU host będzie obsługiwał framework LVGL i komunikował się z procesorem graficznym EVE za pomocą interfejsu SPI.
Zacznij od utworzenia nowego projektu STM32 w STM32CubeIDE dla mikrokontrolera używanego na płytce ewaluacyjnej. Po utworzeniu projektu skonfiguruj urządzenia peryferyjne potrzebne do komunikacji z urządzeniem EVE.
Najważniejszym interfejsem jest SPI, który służy do przesyłania poleceń i danych między MCU a kontrolerem graficznym EVE.
Oprócz interfejsu SPI trzeba skonfigurować kilka sygnałów sterujących jako piny GPIO. Sygnały te służą do sterowania stanem zasilania urządzenia EVE oraz do zarządzania komunikacją z procesorem graficznym (GPU).
Typowe sygnały wymagane przez interfejs EVE to między innymi:
CS
- sygnał Chip Select dla komunikacji SPI
PD
- pin sterujący wyłączaniem, służący do resetowania lub wyłączenia i ponownego włączenia urządzenia EVE
INT
- linia przerwań używana przez procesor graficzny do sygnalizowania zdarzeń do MCU hosta
Po skonfigurowaniu interfejsu SPI i sygnałów GPIO można skompilować projekt i wgrać go na płytkę, żeby sprawdzić, czy podstawowa konfiguracja sprzętowa działa.
Inicjalizacja LVGL i sterownika wyświetlacza EVE
Gdy środowisko projektowe będzie już gotowe, trzeba zainicjować bibliotekę LVGL. Ten krok przygotowuje wewnętrzne struktury LVGL i włącza framework graficzny.
lv_init();
LVGL udostępnia specjalny sterownik dla wyświetlacza dla procesorów graficznych EVE. Sterownik ten przekształca operacje rysowania LVGL na polecenia zrozumiałe dla silnika graficznego EVE.
Sterownik wyświetlacza tworzy się za pomocą funkcji lv_draw_eve_display_create().
lv_display_t * disp = lv_draw_eve_display_create( 1280, 600, LV_DISPLAY_RENDER_MODE_DIRECT );
Te parametry określają rozdzielczość wyświetlacza. W tym przykładzie używamy rozdzielczości 1280×600 wyświetlacza Riverdi RVT70HSBNWC00-B.
Włączanie obsługi ekranu dotykowego
Wyświetlacz Riverdi EVE ma wbudowany kontroler dotyku pojemnościowy, do którego można uzyskać dostęp przez interfejs GPU EVE.
LVGL udostępnia funkcję pomocniczą, która tworzy sterownik urządzenia wejściowego połączonego z silnikiem dotykowym EVE.
lv_draw_eve_touch_create(disp);
Po wywołaniu tej funkcji współrzędne dotykowe wykryte przez kontroler EVE są automatycznie przekazywane do LVGL i przekształcane w zdarzenia wejściowe.
Dzięki temu widżety LVGL, takie jak przyciski, suwaki i listy, mogą reagować na działania użytkownika.
Uruchomienie pierwszego demo LVGL
Po zainicjowaniu sterowników wyświetlacza i wejścia system jest gotowy do renderowania pierwszego interfejsu graficznego.
Prostym sposobem na sprawdzenie, czy wszystko działa, jest stworzenie ekranu z kilkoma standardowymi widżetami LVGL. Poniżej znajdziesz kod demonstracyjny:
static void create_test_ui(void)
{
lv_obj_t * scr = lv_screen_active();
/* Informacje ogólne */
lv_obj_set_style_bg_color(scr, COLOR_BG, 0);
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, 0);
/* Tytuł */
lv_obj_t * title = lv_label_create(scr);
lv_label_set_text(title, "LVGL on Riverdi EVE");
lv_obj_set_style_text_font(title, &lv_font_montserrat_44, 0);
lv_obj_set_style_text_color(title, COLOR_TEXT, 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 48);
/* Podtytuł */
lv_obj_t * subtitle = lv_label_create(scr);
lv_label_set_text(subtitle, "Basic widget compatibility test");
lv_obj_set_style_text_font(subtitle, &lv_font_montserrat_24, 0);
lv_obj_set_style_text_color(subtitle, COLOR_TEXT, 0);
lv_obj_align(subtitle, LV_ALIGN_TOP_MID, 0, 100);
/* --- punkty odniesienia układu --- */
int start_y = 170;
int col_left = 180;
int col_right = 640;
/* Przycisk */
lv_obj_t * btn = lv_button_create(scr);
lv_obj_set_size(btn, 200, 60);
lv_obj_align(btn, LV_ALIGN_TOP_LEFT, col_left, start_y);
lv_obj_set_style_bg_color(btn, COLOR_ACCENT, 0);
lv_obj_t * btn_label = lv_label_create(btn);
lv_label_set_text(btn_label, "Button");
lv_obj_center(btn_label);
/* Slider */
lv_obj_t * slider = lv_slider_create(scr);
lv_obj_set_width(slider, 260);
lv_obj_align(slider, LV_ALIGN_TOP_LEFT, col_right, start_y + 15);
lv_slider_set_value(slider, 45, LV_ANIM_OFF);
lv_obj_set_style_bg_color(slider, COLOR_WIDGET, LV_PART_MAIN);
lv_obj_set_style_bg_color(slider, COLOR_ACCENT, LV_PART_INDICATOR);
/* Slider */
lv_obj_t * sw = lv_switch_create(scr);
lv_obj_align(sw, LV_ALIGN_TOP_LEFT, col_left, start_y + 120);
lv_obj_t * sw_label = lv_label_create(scr);
lv_label_set_text(sw_label, "Switch");
lv_obj_set_style_text_color(sw_label, COLOR_TEXT, 0);
lv_obj_align_to(sw_label, sw, LV_ALIGN_OUT_RIGHT_MID, 20, 0);
/* Checkbox */
lv_obj_t * cb = lv_checkbox_create(scr);
lv_checkbox_set_text(cb, "Checkbox");
lv_obj_set_style_text_color(cb, COLOR_TEXT, 0);
lv_obj_align(cb, LV_ALIGN_TOP_LEFT, col_right, start_y + 120);
/* Bar */
lv_obj_t * bar = lv_bar_create(scr);
lv_obj_set_size(bar, 500, 20);
lv_obj_align(bar, LV_ALIGN_TOP_MID, 0, start_y + 220);
lv_bar_set_value(bar, 70, LV_ANIM_OFF);
lv_obj_set_style_bg_color(bar, COLOR_WIDGET, LV_PART_MAIN);
lv_obj_set_style_bg_color(bar, COLOR_ACCENT, LV_PART_INDICATOR);
lv_obj_t * bar_label = lv_label_create(scr);
lv_label_set_text(bar_label, "Bar");
lv_obj_set_style_text_color(bar_label, COLOR_TEXT, 0);
lv_obj_align_to(bar_label, bar, LV_ALIGN_OUT_TOP_MID, 0, -8);
}
Podsumowanie
W tym poradniku pokazaliśmy, jak uruchomić LVGL na wyświetlaczu Riverdi EVE4, używając płytki ewaluacyjnej Riverdi jako platformy hosta.
Zamiast renderować tradycyjny bufor ramki na MCU, system wykorzystuje silnik graficzny EVE do generowania ostatecznego obrazu. Mikrokontroler główny wysyła polecenia rysowania przez interfejs SPI, a procesor graficzny BT817 tworzy display list i renderuje klatkę na ekranie.
Ta architektura pozwala na uruchamianie złożonych graficznych interfejsów użytkownika na stosunkowo niewielkich mikrokontrolerach, przy jednoczesnym utrzymaniu niskiego zużycia pamięci i obciążenia procesora.
Gdy sterownik wyświetlacza zostanie poprawnie zainicjowany, można używać LVGL do tworzenia pełnoprawnych aplikacji graficznych tak samo, jak w przypadku innych obsługiwanych sterowników wyświetlacza.
Od tego momentu programiści mogą zacząć tworzyć własne interfejsy, korzystając z widżetów LVGL, układów i mechanizmów obsługi zdarzeń.
Dalsze kroki mogą obejmować:
- Wdrażanie niestandardowych ekranów i logiki aplikacji
- Dodawanie obrazów i czcionek zapisanych w pamięci EVE RAM_G
- Optymalizacja komunikacji SPI w celu zwiększenia wydajności renderowania
Żeby to zrobić, zajrzyj na stronę z dokumentacją LVGL i przejrzyj nasz profil Riverdi na GitHubie.
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.
