Come utilizzare la memoria Flash con i chip BT81x

Indice dei contenuti

Per capire Embedded Video Engine (EVE) – BT81x, bisogna ricordare che non ha una soluzione tipica, come nei sistemi embedded con schermi LCD. Che cosa significa?

I chip EVE non hanno frame buffer: ciò significa che tutte le operazioni di visualizzazione vengono eseguite a tempo di esecuzione.

Utilizzando la memoria flash NOR, permette di memorizzare e visualizzare direttamente da essa: immagini, audio e video. È anche possibile utilizzare font personalizzati memorizzati in flash, preparati in EVE Asset Builder (descritto di seguito).

Il BT81x dispone di una memoria flash seriale situata a 80 0000h

Rilevamento della memoria, utilizzando la scheda di valutazione STM32 in configurazione diretta (ponte USB -> SPI)

Per supportare diversi fornitori di chip flash SPI NOR, il primo blocco (4096 byte) della flash è riservato al driver flash chiamato file BLOB, fornito da Bridgetek. Il file BLOB deve essere programmato per primo, in modo che lo stato flash possa entrare in modalità full-speed (veloce). Il chip flash ha un file blob corretto programmato nel suo primo blocco (4096 byte).

Creazione di un file immagine flash

Il file generato è un file *.bin con i dati flash e un file *.map con gli indirizzi e le dimensioni dei file in memoria.

Programmazione della memoria con la scheda di valutazione STM32

Configurazione della scheda di valutazione STM32 e del modulo LCD in modalità diretta:

Scaricare i driver da : https://ftdichip.com/drivers/d2xx-drivers/

Esempi di codice C per le operazioni di flash:

Gli esempi di codice sono disponibili su Riverdi GitHub:
https://github.com/riverdi/EVE3_flash_write
(si tenga presente che gli stessi esempi funzionano per i chip di EVE4 e EVE3).

Per altre piattaforme è sufficiente modificare le funzioni di gestione del file system, come fopen(), fread(), fclose().

Il codice dell’esempio demo utilizza la libreria FatFS per leggere i dati dalla scheda SD e inserirli nella memoria flash NOR di EVE.

Caratteri: Formato legacy

Formato bitmap: Seleziona tutto o una combinazione di L1, L2, L4, L8.

Supporto del comando EVE: Selezionare il comando SETFONT o SETFONT2 per impostare il file di font. MANUALE RIVERDI

SETFONT: genera una tabella metrica di font compatibile con FT80X, l’opzione predefinita.
SETFONT2: genera una tabella metrica dei font compatibile con BT81X/FT81X per il comando Cmd_SetFont2. I file generati con questa opzione non sono compatibili con FT80X.

Indirizzo dei dati del font (tabella metrica + glifo): Indirizzo per inserire i dati del font in RAM_G

Set di caratteri definiti dall’utente: Se non è selezionato (impostazione predefinita), tutti i caratteri del font verranno convertiti. Se viene selezionato, viene convertito solo un elenco di caratteri in un file di testo; i caratteri di questo elenco devono essere definiti nel file di font di input.

Caratteri ASCII stampabili [32-126]: Se si seleziona, i caratteri ASCII con punto di codice da 32 a 126 verranno convertiti.

Uscita:

Genera il file di blocco metrico e i dati bitmap in formato L1, L2, L4, L8.
L’output è un blocco metrico di 148 byte seguito dai dati bitmap grezzi.
Questo strumento genera anche un esempio di codice C per dimostrarne l’utilizzo.
I dati di uscita sono preparati per 1 handle bitmap.

uint8_t font[]=
{
/*Fine dati grezzi bitmap —*/
}
#define FONT_HANDLE (1)
#define FONT_FILE_ADDRESS (RAM_G + 1000)
#define FIRST_CHARACTER (32)
void Load_Font(uint32_t i)
{
Gpu_CoCmd_Dlstart(phost);
App_WrCoCmd_Buffer(phost, CLEAR(1, 1, 1));
App_WrCoCmd_Buffer(phost, COLOR_RGB(255, 255, 255));
Gpu_Hal_WrMem(phost, FONT_FILE_ADDRESS, font, sizeof(font));
//Gpu_Hal_LoadImageToMemory(phost, “path\to\digital-7_24_L8.raw”, FONT_FILE_ADDRESS, LOAD);
Gpu_CoCmd_SetFont2(phost, FONT_HANDLE, FONT_FILE_ADDRESS, FIRST_CHARACTER);
Gpu_CoCmd_Text(phost, 0, 0, FONT_HANDLE, OPT_FORMAT, “display %d “, i);
App_WrCoCmd_Buffer(phost, DISPLAY());
Gpu_CoCmd_Swap(phost);
App_Flush_Co_Buffer(phost);
Gpu_Hal_WaitCmdfifo_empty(phost);
}

Come utilizzare il font personalizzato esteso memorizzato nella memoria flash

1. Per prima cosa è necessario generare i file glypth e xfont dal font ttf:

2. Generare il file immagine flash.bin

3. Programmare Flash (pulsante di aggiornamento), provare a scollegare l’USB se si notano problemi.

4. Codice:

Il font si trova nella memoria flash (file glypth), è necessario copiare xfont nella GRAM.

vuoto
Load_XFont(
vuoto
)
{
uint32_t fontAddr = RAM_G;
// NOTA: ricordarsi di scrivere il file glifo nella flash del BT815 all’indirizzo 4096.
// Passare il flash in modalità FULL
Gpu_CoCmd_FlashFast(phost, 0);
// Caricare il file xfont nella RAM grafica
Gpu_CoCmd_FlashRead(phost, RAM_G, 52096, 4416);
Gpu_Hal_WaitCmdfifo_empty(phost);
Gpu_CoCmd_Dlstart(phost);
App_WrCoCmd_Buffer(phost, CLEAR(1, 1, 1));
App_WrCoCmd_Buffer(phost, COLOR_RGB(255, 255, 255));
Gpu_CoCmd_SetFont2(phost, 1, fontAddr, 0);
Gpu_CoCmd_Text(phost, 50, 50, 1, 0, u8“ABCDEFG 1234567890”);
App_WrCoCmd_Buffer(phost, DISPLAY());
Gpu_CoCmd_Swap(phost);
App_Flush_Co_Buffer(phost);
Gpu_Hal_WaitCmdfifo_empty(phost);
}

Immagini

EVE accetta file di immagini JPEG/PNG/BMP da convertire.

Formato di uscita: Il formato di uscita delle immagini è uno dei seguenti:

ARGB1555, L1, L2, L4, L8, RGB232, ARGB2, ARGB4, RGB565, PALETTED565, PALETTED4444, PALETTED8, formato ASTC da 4×4 a 12×12, formato DXT1ASTC possono essere utilizzati anche per riprodurre animazioni.

Esempio di codice C per la visualizzazione di un file JPEG (il file JPEG viene decompresso in GRAM):

vuoto statico
Load_Jpeg(Gpu_Hal_Context_t *phost, uint32_t adr)
{
Gpu_CoCmd_Dlstart(phost);
App_WrCoCmd_Buffer(phost, CLEAR(1, 1, 1));
App_WrCoCmd_Buffer(phost, COLOR_RGB(255, 255, 255));
//Gpu_CoCmd_FlashHelper_SwitchFullMode(&host);
Gpu_CoCmd_FlashSource(phost, adr);
Gpu_CoCmd_LoadImage(phost, 0, OPT_FLASH );
//Inizia a disegnare la bitmap
App_WrCoCmd_Buffer(phost, BEGIN(BITMAPS));
App_WrCoCmd_Buffer(phost, VERTEX2II(0, 0, 0, 0));
App_WrCoCmd_Buffer(phost, END());
App_WrCoCmd_Buffer(phost, RESTORE_CONTEXT());
App_WrCoCmd_Buffer(phost, DISPLAY());
Gpu_CoCmd_Swap(phost);
App_Flush_Co_Buffer(phost);
Gpu_Hal_WaitCmdfifo_empty(phost);
//platform_sleep_ms(3000);
}

Immagine ASTC visualizzata direttamente dalla memoria flash:

vuoto statico
Load_ImageASTC(Gpu_Hal_Context_t *phost, uint32_t adr, uint16_t fmt)
{
uint16_t iw = 1280;
uint16_t ih = 800;
Gpu_CoCmd_Dlstart(phost);
//App_WrCoCmd_Buffer(phost, CLEAR(1, 1, 1));
//App_WrCoCmd_Buffer(phost, COLOR_RGB(255, 255, 255));
//Gpu_CoCmd_FlashSource(phost, adr);
Gpu_CoCmd_SetBitmap(phost, (0x800000 | adr/ 32 ), fmt, iw, ih);
//Gpu_CoCmd_SetBitmap(phost, RAM_G,RGB565 , iw, ih);
//Inizia a disegnare la bitmap
App_WrCoCmd_Buffer(phost, BEGIN(BITMAPS));
App_WrCoCmd_Buffer(phost, VERTEX2F(0, 0));
App_WrCoCmd_Buffer(phost, END());
App_WrCoCmd_Buffer(phost, RESTORE_CONTEXT());
App_WrCoCmd_Buffer(phost, DISPLAY());
Gpu_CoCmd_Swap(phost);
App_Flush_Co_Buffer(phost);
Gpu_Hal_WaitCmdfifo_empty(phost);
}

Video da memoria flash

Il file video deve essere convertito in *.avi in formato MJEG.

Codice per eseguire video dalla memoria flash:

Gpu_CoCmd_FlashHelper_SwitchFullMode(&host);
Gpu_Hal_Wr32(phost, REG_PLAY_CONTROL, 1);
Gpu_CoCmd_Dlstart(phost);
App_WrCoCmd_Buffer(phost, CLEAR(1, 1, 1));
App_WrCoCmd_Buffer(phost, COLOR_RGB(255, 255, 255));
Gpu_CoCmd_FlashSource(phost, adr);
App_WrCoCmd_Buffer(phost, CMD_PLAYVIDEO);
App_WrCoCmd_Buffer(phost, OPT_FLASH|OPT_FULLSCREEN|OPT_NOTEAR);
App_Flush_Co_Buffer(phost);
Gpu_Hal_WaitCmdfifo_empty(phost);

Audio

Convertire WAV/MP3 in file compatibili con EVE.

File di ingresso: il file audio originale da convertire.

Cartella di output: Cartella contenente i file convertiti.

Formato di uscita: Formato audio dell’uscita

PCM firmato a 8 bit
Legge u a 8 bit
4 bit IMA ADPCM

Generare l’animazione

Converte un file GIF o un elenco di file PNG/JPEG/BMP in un file di animazione compatibile con EVE. L’animazione è supportata dal chip BT81X e successivi.

File o cartella di input: Gli utenti possono selezionare un file GIF o una cartella di immagini. La cartella delle immagini deve contenere file PNG/JPEG/BMP il cui nome sequenziale è definito dall’espressione regolare “.*[0- 9]+\.(png|jpeg|jpg|bmp)”. Il numero indica la sequenza di fotogrammi animati. Ad esempio: “001.png”, “002.png”.

Cartella di output: Cartella contenente i file convertiti.

Impronte dei blocchi ASTC: Selezionare uno dei seguenti: 4×4, 5×4, 5×5, 6×5, 6×6, 8×5, 8×6, 8×8, 10×5, 10×6, 10×8, 10×10, 12×10, 12×12

Velocità di compressione: molto veloce, veloce, media, approfondita ed esaustiva. La qualità aumenta da molto veloce a esaustiva, mentre la velocità di codifica diminuisce.

Scarica la versione PDF