Indice dei contenuti
Come utilizzare la memoria Flash con i chip BT81x
Per capire l’Embedded Video Engine (EVE) – BT81x, devi ricordare che non ha una soluzione tipica, come nei sistemi embedded con schermi LCD. Che cosa significa?
I chip EVE non hanno un frame buffer: ciò significa che tutte le operazioni di visualizzazione vengono eseguite in tempo reale.
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 dei 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 l’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 dei dati grezzi della 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\todigital-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.
void Load_XFont(void)
{
uint32_t fontAddr = RAM_G;
// NOTA: Ricordati 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, il formato DXT1ASTC può essere utilizzato anche per riprodurre animazioni.
Esempio di codice C per la visualizzazione di un file JPEG (il file JPEG viene decompresso in GRAM):
void 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:
void 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: La cartella contiene i file convertiti.
Impronte dei blocchi ASTC: Seleziona 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.