Il controllo della retroilluminazione e la rotazione dello schermo sono operazioni fondamentali per il display che hanno un impatto diretto sul comportamento del sistema nei progetti basati su STM32. Sono indipendenti dalla logica applicativa, ma strettamente collegate alla configurazione hardware e alle funzionalità del framework grafico.
In questo articolo spieghiamo come i moduli display STM32 Riverdi implementano il controllo della retroilluminazione basato su PWM utilizzando TIM15 e un driver LED dedicato e come la rotazione dello schermo viene gestita in modo diverso nei progetti LVGL e TouchGFX. L’attenzione si concentra sui dettagli pratici dell’implementazione e sulla separazione architettonica.
Controllo della retroilluminazione dei display STM32 Riverdi
Il controllo della retroilluminazione è una delle operazioni fondamentali quando si lavora con i display embedded. A differenza del rendering grafico o della gestione del tocco, il controllo della retroilluminazione è indipendente dal framework dell’interfaccia grafica e non dipende dal fatto che l’applicazione utilizzi LVGL, TouchGFX o un altro stack grafico.
Nei moduli display Riverdi basati su STM32, la luminosità della retroilluminazione è controllata tramite un segnale PWM hardware, generato da un timer STM32.
Moduli STM32 Riverdi supportati
Il metodo descritto in questo articolo si applica ai moduli display STM32 Riverdi, come ad esempio:
- RVT121
- RVT101
- RVT70
- RVT50
Lo stesso principio può essere utilizzato su altre piattaforme Riverdi STM32 che espongono un ingresso di retroilluminazione controllato da PWM.
Principio di controllo della retroilluminazione
Nei moduli display Riverdi basati su STM32, il microcontrollore non pilota direttamente la retroilluminazione a LED. Al contrario, l’STM32 genera un segnale di controllo PWM che viene inviato a un circuito di pilotaggio della retroilluminazione LED dedicato .
Il driver della retroilluminazione è una sorgente a corrente costante, progettata per regolare la corrente che scorre attraverso le stringhe di LED. Il segnale PWM non modula direttamente la tensione dei LED. Controlla invece il ciclo di lavoro effettivo del driver, permettendo alla corrente media dei LED di variare tra lo 0% e il 100% del suo valore nominale.
L’architettura può essere riassunta come segue:
- Il timer dell’STM32 (ad esempio, TIM15) genera un segnale PWM.
- Il segnale PWM viene indirizzato all’ingresso del driver della retroilluminazione.
- Il driver della retroilluminazione regola la corrente dei LED.
- l ciclo di lavoro del segnale PWM determina la luminosità effettiva.
Questo significa che:
- La frequenza PWM è definita dalla configurazione del timer
- La luminosità è proporzionale al ciclo di lavoro PWM.
- La corrente del LED è sempre regolata dal driver, non dal GPIO dell’MCU.
Ciclo di lavoro più elevato → corrente media del LED più elevata → display più luminoso
Ciclo di lavoro più basso → corrente media del LED più bassa → display più debole
Perché i LED sono pilotati da una sorgente di corrente regolata:
- Il controllo della luminosità è lineare e stabile,
- La durata dei LED è protetta,
- il comportamento termico è prevedibile,
- l’efficienza rimane elevata in tutto l’intervallo di funzionamento.
Questo approccio prevede:
- controllo fluido della luminosità,
- bassa perdita di potenza,
- la corretta regolazione della corrente della retroilluminazione a LED,
- la completa indipendenza dell’hardware dal framework dell’interfaccia grafica.
Requisiti hardware e software
Prima di regolare il livello di retroilluminazione, assicurati che:
- il display è collegato correttamente al modulo STM32,
- la scheda è collegata a un PC tramite ST-Link,
- il progetto è costruito utilizzando un modello software supportato (LVGL o TouchGFX).
Per il controllo della retroilluminazione non è necessario modificare la configurazione del framework della GUI.
Timer utilizzato per il controllo della retroilluminazione
Nei moduli display Riverdi STM32, la retroilluminazione viene controllata utilizzando:
- TIM15 (su entrambe le infrastrutture U5 e H7)
- Uscita PWM hardware
- Canale 1
La configurazione del PWM si trova nel file tim.c del progetto, all’interno della funzione MX_TIM15_Init().
Esempio di configurazione PWM
Il canale PWM viene configurato utilizzando le strutture HAL standard dell’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;
se (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_1) !=
HAL_OK)
{
Error_Handler();
}Il parametro più importante è sConfigOC.Pulse.
Gamma di luminosità e significato
La luminosità della retroilluminazione è controllata dal ciclo di lavoro PWM:
- 0 → retroilluminazione disattivata
- 998 → luminosità massima
Qualsiasi valore compreso tra 0 e 998 determina un livello di luminosità proporzionale.
Regolazione della luminosità in tempo reale
Oltre alla configurazione statica, il livello di retroilluminazione può essere modificato anche in fase di esecuzione scrivendo direttamente sul registro del timer:
TIM15->CCR1 = il tuo_nuovo_valore_di_impulso;
Questo permette di:
- controllo dinamico della luminosità,
- oscuramento basato sulla luce ambientale,
- modalità di risparmio energetico,
- effetti di dissolvenza in entrata e in uscita.
Non è necessaria la reinizializzazione del display.
Rotazione dello schermo sui display STM32
A differenza del controllo della retroilluminazione, la rotazione dello schermo non è un’operazione puramente hardware sull’STM32.
La periferica del controller del display LCD TFT (LTDC) non supporta la rotazione dell’immagine, il che significa che la rotazione deve essere gestita a livello di livello di struttura grafica.
A seconda del framework GUI scelto, l’implementazione varia in modo significativo.
Questa sezione spiega entrambi gli approcci utilizzati sui display STM32 Riverdi:
- Rotazione basata su LVGL
- Rotazione basata su TouchGFX
Rotazione dello schermo con LVGL
Quando si utilizzano moduli display STM32 Riverdi con pannelli RGB, la periferica STM32 LTDC invia i pixel dalla memoria linea per linea. Poiché LTDC non supporta la rotazione hardware, l’unico modo affidabile per ruotare l’immagine è farlo via software prima che i pixel raggiungano il framebuffer LTDC.
LVGL supporta la rotazione del display attraverso:
lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_xxx);
dove xxx può essere 0, 90, 180 o 270.
Tuttavia, questa chiamata aggiorna il sistema di coordinate interno di LVGL e la gestione del layout; non ruota automaticamente i dati dei pixel per le pipeline RGB basate su LTDC. Per questo motivo, la rotazione dei pixel deve essere gestita all’interno del callback LVGL flush.
Dove si inserisce la rotazione nella pipeline LVGL
In questa configurazione:
- LVGL esegue il rendering di piccole “piastrelle” in un buffer di lavoro (px_map) utilizzando la modalità di rendering PARZIALE.
- Il callback flush (disp_flush) scrive le tessere renderizzate nel framebuffer LTDC.
- Se la rotazione è abilitata, il callback di flush ruota il riquadro prima di scriverlo nel framebuffer.
- Le coordinate del tocco rimangono coerenti perché LVGL conosce la rotazione corrente del display.
Inizializzazione LVGL (rendering PARZIALE + rotazione)
Il display viene creato e configurato in lvgl_port_display.c:
void lvgl_display_init(void)
{
disp = lv_display_create(MY_DISP_HOR_RES, MY_DISP_VER_RES);
__attributo__((sezione(".my_ram_d2_data"))
statico uint8_t buf1[288 * 1024];
lv_display_set_buffers(disp, (void *)buf1, NULL, sizeof(buf1),
LV_DISPLAY_RENDER_MODE_PARTIAL);
/* Imposta la rotazione desiderata */
lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_90);
/* Registra il callback di flush */
lv_display_set_flush_cb(disp, disp_flush);
}
Flush callback (rotazione software nel framebuffer LTDC)
Di seguito è riportato il callback di flush utilizzato per i display Riverdi STM32 con LTDC.
Supporta la rotazione per:
- Trasformare l’area di destinazione tramite lv_display_rotate_area(), e
- Ruota i dati dei pixel tramite lv_draw_sw_rotate() prima di scriverli nel framebuffer
.
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 byte */
/* Calcola l'area di destinazione dopo la rotazione */
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);
/* Indirizzo del framebuffer LTDC */
uint8_t * fb = (uint8_t *)hltdc.LayerCfg[0].FBStartAdress;
fb += (rot_area.y1 * fb_stride) + (rot_area.x1 * px_size);
/* Manutenzione della cache (necessaria quando il framebuffer è nella SDRAM esterna) */
SCB_CleanInvalidateDCache();
lv_display_rotation_t r = lv_display_get_rotation(display);
if(r == LV_DISPLAY_ROTATION_0) {
/* Percorso veloce: nessuna rotazione */
for(int32_t y = 0; y < src_h; y++) {
lv_memcpy(fb, px_map, src_stride);
px_map += src_stride;
fb += fb_stride;
}
} else {
/* Ruota la piastrella renderizzata direttamente nel framebuffer */
lv_draw_sw_rotate(px_map, fb,
src_w, src_h,
src_stride, fb_stride,
r, cf);
}
/* Notifica a LVGL che il lavaggio è stato completato */
lv_display_flush_ready(display);
}Risultato
Con questo approccio:
- l’immagine viene ruotata fisicamente prima dell’uscita LTDC,
- Il layout e il rendering di LVGL rimangono coerenti,
- le coordinate tattili rimangono allineate con l’interfaccia utente ruotata,
- non è necessario modificare la configurazione della temporizzazione LTDC.
Rotazione dello schermo su STM32 con TouchGFX
A differenza di LVGL, TouchGFX gestisce la rotazione dello schermo a livello di framework e di configurazione. Per la maggior parte dei progetti di display Riverdi basati sull’STM32, la rotazione può essere abilitata senza modificare i driver di visualizzazione di basso livello o il codice di gestione del framebuffer.
Questo rende TouchGFX particolarmente comodo quando:
- l’orientamento del display è noto al momento della progettazione,
- la rotazione non deve essere modificata dinamicamente in fase di esecuzione,
- è preferibile un approccio veloce e manutenibile basato sulla configurazione.
Concetto di rotazione TouchGFX
TouchGFX astrae la pipeline di visualizzazione e la gestisce:
- layout del framebuffer,
- orientamento del rendering,
- trasformazioni di coordinate,
- mappatura dell’input tattile.
Il risultato è che:
- non è necessaria la rotazione manuale dei pixel nel percorso di lavaggio LTDC,
- non è necessaria alcuna manipolazione personalizzata del framebuffer,
- La rotazione viene applicata in modo coerente al rendering e all’input tattile.
Abilitazione della rotazione dello schermo nel designer TouchGFX
La rotazione dello schermo viene configurata direttamente in TouchGFX Designer.
La denominazione esatta può variare leggermente a seconda della versione di TouchGFX, ma il flusso di lavoro di
è coerente.
Passo 1 – Aprire la configurazione del display
In TouchGFX Designer:
- Apri il tuo progetto.
- Vai alla sezione Display / Scheda / Configurazione dell’applicazione.
- Individua l’impostazione Orientamento del display o Rotazione dello schermo.
Sintesi
Nei moduli STM32 Riverdi, la luminosità della retroilluminazione è controllata da un PWM hardware generato da TIM15 e regolato da un driver LED a corrente costante. Il duty cycle definisce la luminosità in modo indipendente dal framework della GUI, consentendo un funzionamento stabile e prevedibile.
La rotazione dello schermo non è supportata dall’hardware LTDC e deve essere gestita a livello grafico. In LVGL, la rotazione richiede la trasformazione dei pixel via software nel callback di flush. In TouchGFX, la rotazione viene configurata a livello di framework senza modificare i driver di visualizzazione di basso livello.
La separazione del controllo a livello hardware dalle responsabilità del livello grafico garantisce un’architettura pulita e un comportamento affidabile nei sistemi di visualizzazione basati su STM32.
SCOPRI IL NOSTRO
Carta bianca
Ottieni un’interazione perfetta tra utente e display con il giusto IC per sensore tattile. Hai mai avuto problemi con eventi di tocco fantasma o con la certificazione? Potenzia la tua ricerca e sviluppo come un professionista con il nostro Whitepaper!
Consulta il nostro catalogo prodotti e scopri come puoi risparmiare sulla qualità, non sulla qualità.
