NXP AN14263 Implementa il riconoscimento facciale della GUI LVGL su Framewor

Informazioni sul prodotto

Specifiche

• Nome del prodotto: Riconoscimento facciale GUI LVGL su Framework
• Revisione del documento: 1 – 19 aprile 2024
• Parole chiave: Riconoscimento facciale, GUI LVGL, Framework

Istruzioni per l'uso del prodotto

1. Sopraview
   Questo prodotto consente il modello di algoritmo di visione AI&ML per il riconoscimento facciale su un framework per implementare la funzione di riconoscimento facciale con una semplice GUI LVGL example sulla scheda SLN-TLHMI-IOT.
2. Quadro finitoview
   Il software della soluzione è progettato attorno all'architettura framework che include gestori di dispositivi responsabili della gestione dei dispositivi, dispositivi HAL per astrarre i dettagli sottostanti ed eventi per la comunicazione tra diversi dispositivi.
3. Caratteristiche
   Il prodotto consente l'implementazione della funzione di riconoscimento facciale tramite fotocamera preview sullo schermo della GUI con pulsanti per attivare la registrazione, il riconoscimento e la rimozione dei volti. I dati dei volti registrati vengono archiviati su Flash tramite a file sistema.
4. Contenuto della nota applicativa
   La nota applicativa presenta una schermata GUI LVGL con fotocamera preview e pulsanti per le azioni relative al volto. Aiuta gli sviluppatori a comprendere il framework e come implementare il riconoscimento facciale utilizzando l'examplui.

Sopraview

NXP ha lanciato un kit di sviluppo di soluzioni denominato SLN-TLHMI-IOT incentrato sulle applicazioni HMI intelligenti. Abilita l'HMI intelligente con visione ML, voce e interfaccia utente grafica implementata su un MCU NXP i.MX RT117H. Basato sull'SDK, il software della soluzione è costruito su un progetto chiamato framework che supporta progetti flessibili e personalizzazione delle funzioni visive e vocali. Per aiutare gli utenti ad utilizzare al meglio la piattaforma software, vengono forniti alcuni documenti di base, ad esample, la guida utente per lo sviluppo del software. La guida introduce la progettazione software di base e l'architettura delle applicazioni coprendo tutti i componenti della soluzione compreso il framework per aiutare gli sviluppatori a implementare in modo più semplice ed efficiente le loro applicazioni utilizzando SLN-TLHMI-IOT.
Per maggiori dettagli sulla soluzione e sui documenti rilevanti, visitare il web pagina della soluzione HMI intelligente NXP EdgeReady basata su i.MX RT117H con ML Vision, voce e interfaccia utente grafica. Tuttavia, non è ancora così semplice per gli sviluppatori implementare le proprie applicazioni HMI intelligenti facendo riferimento a queste guide di base. Sono previste una serie di note applicative per aiutare a studiare passo dopo passo lo sviluppo del framework. Questa nota applicativa si basa sull'implementazione della GUI LVGL Camera Preview sul Quadro (documento AN14147). Questa nota applicativa descrive come abilitare il modello di algoritmo di visione AI&ML per il riconoscimento facciale sul framework per implementare la funzione di riconoscimento facciale tramite fotocamera preview sullo schermo della GUI con una semplice GUI LVGL example sulla scheda SLN-TLHMI-IOT. Nella nota applicativa, l'example presenta una schermata GUI LVGL con un preamplificatore per fotocameraview e alcuni pulsanti per attivare la registrazione, il riconoscimento e la rimozione dei volti. I dati del viso registrati vengono memorizzati su Flash tramite un po' file sistema.

Ad alto livello, la nota applicativa contiene i seguenti contenuti:

• Abilita la funzione di riconoscimento facciale sul framework.
• Aggiungi il supporto del database dei volti sul framework tramite file sistema su Flash.
• Implementare l'app GUI LVGL. Attraverso le introduzioni di cui sopra, questo documento aiuta gli sviluppatori a:
• Comprendere più approfonditamente la struttura e il software della soluzione HMI intelligente.
• Sviluppa il riconoscimento facciale AI e ML sul framework con l'app LVGL GUI.

Quadro finitoview
La soluzione software è progettata principalmente attorno all'uso dell'architettura framework composta da diverse parti:

• Gestori dispositivi: la parte principale
• Dispositivi HAL (Hardware Abstraction Layer).
• Messaggi/Eventi

Come mostrato nella Figura 1, l'overview del meccanismo del quadro è:

I gestori dei dispositivi sono responsabili della gestione dei dispositivi utilizzati dal sistema. Ogni tipo di dispositivo (input, output e così via) ha il proprio gestore dispositivi specifico per il tipo. Con un gestore dispositivi che si avvia dopo la registrazione dei dispositivi, attende e controlla un messaggio per trasferire i dati ai dispositivi e ad altri gestori dopo aver inizializzato e avviato i dispositivi registrati. I dispositivi HAL sono scritti sopra il codice del driver di livello inferiore, contribuendo ad aumentare la comprensibilità del codice estraendo molti dei dettagli sottostanti.

Gli eventi sono un mezzo attraverso il quale le informazioni vengono comunicate tra diversi dispositivi tramite i loro gestori. Quando viene attivato un evento, il dispositivo che per primo ha ricevuto l'evento comunica l'evento al proprio gestore, quindi a sua volta avvisa gli altri gestori designati a ricevere l'evento.

La progettazione architettonica del framework era incentrata su tre obiettivi principali:

1. Facilità d'uso
2. Flessibilità/Portabilità
3. Prestazione

Il framework è progettato con l’obiettivo di accelerare il time-to-market per la visione e altre applicazioni di machine learning. Per garantire un rapido time-to-market, è fondamentale che il software stesso sia facile da comprendere e modificare. Tenendo presente questo obiettivo, l'architettura del framework è facile da modificare senza essere restrittiva e senza compromettere le prestazioni.
Per ulteriori dettagli sul framework, consultare la Guida per l'utente dello sviluppo del software Smart HMI (documento MCU-SMHMI-SDUG).

Libreria grafica leggera e versatile (LVGL)
LVGL (Light and Versatile Graphics Library) è una libreria grafica gratuita e open source che fornisce tutto ciò di cui hai bisogno per creare una GUI incorporata con elementi grafici facili da usare, bellissimi effetti visivi e un ingombro di memoria ridotto.

Guida dell'interfaccia grafica
GUI Guider è uno strumento di sviluppo dell'interfaccia utente grafica intuitivo di NXP che consente il rapido sviluppo di display di alta qualità con la libreria grafica LVGL open source. L'editor drag-and-drop di GUI Guider semplifica l'utilizzo di molte funzionalità di LVGL come widget, animazioni e stili per creare una GUI con una codifica minima o nessuna.

Con un semplice clic puoi eseguire la tua applicazione in un ambiente simulato o esportarla in un progetto di destinazione. Il codice generato da GUI Guider può essere facilmente aggiunto al tuo progetto, accelerando il processo di sviluppo e consentendoti di aggiungere facilmente un'interfaccia utente incorporata alla tua applicazione. GUI Guider può essere utilizzato gratuitamente con gli MCU generici e crossover di NXP e include modelli di progetto integrati per diverse piattaforme supportate. Per ulteriori informazioni sullo sviluppo LVGL e GUI su GUI Guider, consulta Libreria grafica leggera e versatile e GUI Guider.

Sviluppo dell'ambiente

Innanzitutto, preparare e configurare l'ambiente hardware e software per l'implementazione dell'example sul quadro.

Ambiente hardware
L'ambiente hardware è configurato per verificare l'exampon:

• Il kit di sviluppo HMI intelligente basato su NXP i.MX RT117H (il kit SLN_TLHMI_IOT)
• SEGGER J-Link con adattatore Cortex-M a 9 pin e V7.84a o una versione più recente del driver

ambiente software
L'ambiente software è configurato per lo sviluppo dell'exampon:

• MCUXpressoIDE V11.7.0
• Guida GUI V1.6.1-GA
• lvgl_gui_camera_preview_cm7 – esample codice della seconda nota applicativa come software base dello sviluppo. Per i dettagli, vedere https://mcuxpresso.nxp.com/appcodehub.
• RT1170 SDK V2.13.0 – come risorsa di codice per lo sviluppo.
• Software SLN-TLHMI-IOT V1.1.2: codice sorgente HMI intelligente rilasciato sul repository NXP GitHub come risorsa di codice per lo sviluppo. Per i dettagli, vedere: GitHub – NXP/mcu-smhmi alla v1.1.2

Per dettagli sull'acquisizione e la configurazione dell'ambiente software, vedere: Guida introduttiva a SLN-TLHMI-IOT.

Architettura di visione sul framework

L'architettura di visione sul framework è mostrata nella Figura 2. L'algoritmo di visione HAL (OASIS_HAL) ha i seguenti processi:

• Effettua la registrazione e il riconoscimento dei volti tramite il modello di algoritmo di visione AI&ML dopo aver ricevuto gli eventi correlati dall'output dell'interfaccia utente HAL. Notifica i risultati dell'inferenza dal modello dell'algoritmo all'HAL dell'interfaccia utente di output.
• Accede (aggiungi, elimina...) al database delle caratteristiche del viso in base al piccolo file sistema chiamando le API di FaceDB HAL dopo aver ricevuto i relativi eventi dall'output UI HAL.
• Richiedere il fotogramma video della telecamera dall'HAL della telecamera durante la registrazione e il riconoscimento del volto.

Implementare il riconoscimento facciale sul framework

Il riconoscimento facciale della GUI LVGL, ad esample (l'esample viene fornito più avanti) sul framework è implementato in base all'exampcodici le dell'implementazione della GUI LVGL Camera Preview sul Quadro (documento AN14147).

Per aver dimostrato il riconoscimento facciale nell'example, la funzione di base dell'app GUI (vedere la schermata principale nella Figura 3) è progettata come descritto di seguito:

• L'app GUI attiva l'evento di registrazione o riconoscimento del volto nell'HAL dell'interfaccia utente di output quando si fa clic sul pulsante Registrazione o Riconoscimento. E l'output dell'HAL dell'interfaccia utente notifica l'evento di aggiunta di un utente all'algoritmo di visione HAL dopo che la registrazione del volto ha avuto esito positivo.
• L'app GUI attiva l'evento di eliminazione di un utente nell'HAL dell'interfaccia utente di output quando si fa clic sul pulsante Elimina utente dopo che il volto dell'utente è stato riconosciuto.
• L'app GUI attiva l'evento di arresto dell'esecuzione dell'algoritmo Oasis sull'output HAL dell'interfaccia utente quando si fa clic sullo schermo all'esterno dei pulsanti e delle immagini.

Preparare il pacchetto software per l'implementazione dell'examplui.

• Clona il software di base lvgl_gui_camera_preview_cm7. Cambia il nome del progetto e il main filenome su lvgl_gui_face_rec_cm7.
• È necessario aggiornare il framework nel software poiché i codici sorgente per il core del framework hanno iniziato ad essere pubblici su GitHub dalla versione 1.1.2.
• Sostituisci la cartella framework con la copia della V1.1.2 da GitHub ad eccezione del file files fwk_log.h e fwk_common.h sotto inc\ poiché sono stati modificati per la serie di note applicative. Le operazioni sono mostrate nella Figura 4:
• Elimina la cartella framework_cm7 nel gruppo libs e rimuovi la libreria framework_cm7 e il relativo percorso di ricerca configurato in Progetto > Proprietà > C/C++ Build > Impostazioni > Impostazioni strumento > MCU C++ Linker > Librerie poiché viene fornito il codice sorgente del core.

Abilita la funzione di riconoscimento facciale sul framework
La funzionalità di riconoscimento facciale si basa sul modello dell'algoritmo di visione ML fornito come libreria statica: una libreria runtime Oasis Lite di NXP. La libreria è una libreria AI piccola, altamente efficiente, personalizzata e ottimizzata. Il modello include il rilevamento del volto, il riconoscimento del volto, il rilevamento del vetro e il rilevamento della vitalità. Fornisce principalmente l'API OASISLT_run_extended() per eseguire la pipeline di riconoscimento facciale aggiornando i risultati al chiamante tramite callback di eventi e aggiungendo/aggiornando/eliminando volti nel database tramite callback del database di volti dopo aver specificato le informazioni sul frame di origine, i callback e la memoria pool utilizzato dalla libreria chiamando un'altra API OASISLT_init() durante l'inizializzazione. La chiamata delle API e le funzioni di callback sono implementate nella visione algoritmo HAL del framework.

Aggiunta la libreria di modelli algoritmici di visione

1. Copia la cartella Oasis contenente la libreria e la relativa intestazione file da smart HMI\coffee_machine\cm7\libs\ nella cartella libs dell'example SW.
2. Aggiungi il percorso di ricerca dell'intestazione file in Progetto > Proprietà > Compilazione C/C++ > impostazioni > Impostazioni strumento > Compilatore C MCU > Include e compilatore C++ MCU > Include: "${workspace_loc:/${ProjName}/libs/oasis/include}"
3. Aggiungi la libreria e il suo percorso di ricerca su Progetto > Proprietà > C/C++ Build > impostazioni > MCU C+ + Linker > Librerie: liboasis_lite2D_DEFAULT_117f_ae.a “${workspace_loc:/${ProjName}/libs/oasis}” e la definizione della macro a abilitare la funzionalità su Progetto > Proprietà > Compilazione C/C++ > impostazioni > Impostazioni strumento > Compilatore C MCU > Preprocessore e compilatore MCU C++ > Preprocessore: SMART_TLHMI_2D

Abilita l'algoritmo di visione HAL
L'HAL dell'algoritmo di visione fa funzionare il modello dell'algoritmo di visione e risponde i risultati all'HAL di output dell'interfaccia utente dopo aver ricevuto gli eventi da esso.

Per abilitarlo, clonare il driver HAL simile esistente file dove sono implementate le seguenti funzioni:

• Implementare i callback delle operazioni del database dei volti e della gestione degli eventi.
• Fai funzionare l'algoritmo di visione chiamando le API della libreria Oasis.
• Accedi al database dei volti degli utenti e al database delle app (non è necessario nell'esample).
• Ricevere eventi e inviare risultati all'output dell'HAL dell'interfaccia utente.

I principali lavori per implementare l'HAL per l'exampsono:

• Clonare il driver HAL simile esistente file e modificare i nomi correlati.
• Rimuovi i codici relativi alle operazioni sui dati dell'app.
• Aggiorna le definizioni e le funzioni per la gestione degli eventi dall'HAL dell'interfaccia utente di output secondo l'esampdesign.
• Aggiungi le configurazioni richieste nell'inizializzazione di Oasis.

Di seguito i passaggi dettagliati:

1. Clona hal_vision_algo_oasis_coffeemachine.c. Cambiare il filenome in hal_vision_algo_oasis_guifacerec.c. E sostituisci tutte le stringhe CoffeeMachine con GUIFaceRec nel file file.
2. Rimuovere i codici contenenti la stringa coffeedb (non case-sensitive) relativa al database dell'app, ad esample, #include hal_sln_coffeedb.h.
3. Modificare la funzione HAL_VisionAlgoDev_OasisGUIFaceRec_InputNotify() per gestire gli eventi dall'output dell'interfaccia utente HAL.
   • Modificare la definizione dell'evento kEventFaceRecId_RegisterCoffeeSelection in kEventFaceRecId_RegisterUserFace e la stringa della struttura regCoffeeSelection in regGUIFaceRec per la gestione dell'evento per aggiungere nuovi dati sulle caratteristiche del volto al database.
   • Per mostrare il processo standard delle azioni di riconoscimento facciale nell'example, modificare la gestione nel caso di kEventFaceRecID_OasisSetState con le definizioni degli stati:
     • kOASISLiteState
     • Registrazione kOASISLiteState
     • Riconoscimento kOASISLiteState
     • Fermato
4. Aggiungere e modificare le definizioni degli eventi menzionati nel passaggio precedente.
   • Copia l'intestazione file smart_tlhmi_event_descriptor.h da smart HMI\coffee_machine \cm7\source\event_handlers\ nella cartella source dell'example SW. Aggiorna il file come di seguito:
   • Modificare la definizione dell'evento kEventFaceRecId_RegisterCoffeeSelection in kEventFaceRecId_RegisterUserFace nel tipo enum _event_smart_tlhmi_id e la stringa della struttura regCoffeeSelection in regGUIFaceRec nella struttura _event_smart_tlhmi. Quindi, modifica la struttura Register_coffee_selection_event_t per regCoffeeSelection in Register_gui_facerec_event_t.
   • Elimina gli altri contenuti utilizzati per l'app della macchina da caffè, ad esample, la riga di codice relativa alla voce: #include “hal_event_descriptor_voice.h”.
   • Aggiungi i tipi kOASISLiteState_Stopped e kOASISLiteState_Running al tipo enum paradise_lite_state_t in hal_vision_algo.h in framework>hal>vision nel progetto come di seguito:
     typedef enum _oasis_lite_state {
     • kOASISLiteState
     • In esecuzione, kOASISLiteState
     • Arrestato, kOASISLiteState
     • Riconoscimento,
     • kOASISLiteState
     • Registrazione, kOASISLiteState
     • Deregistrazione, kOASISLiteState
     • Registrazione remota, kOASISLiteState
     • Contare
   • Utilizzare la struttura aggiornata dioasi_lite_state_t per perfezionare la struttura oasi_state_event_t in hal_event_descriptor_face_rec.h sotto framework>hal>vision nel progetto come di seguito: typedef struct _oasis_state_event_t {oasis_lite_state_t state; } oasi_state_event_t;
5. Cambia tutto kEventInfo_Remote in kEventInfo_Local per inviare eventi dall'algoritmo di visione HAL ad altri HAL in esecuzione sullo stesso core poiché nell'ex viene utilizzato single core anziché dual-coreamplui.
6. Aggiungi e modifica le seguenti configurazioni per l'inizializzazione dell'oasi in OASISLT_init():
   • Aggiungi le definizioni delle macro e le sezioni di memoria per il fotogramma video in board_define.h: #define OASIS_RGB_FRAME_WIDTH 800
     • #define OASIS_RGB_FRAME_HEIGHT 600
     • #define OASIS_RGB_FRAME_SRC_FORMAT kPixelFormat_YUV1P444_RGB
     • #define OASIS_RGB_FRAME_BYTE_PER_PIXEL 3
     • #define AT_FB_SHMEM_SECTION_ALIGN(var, alignbytes) \
     • __attribute__((section(“.bss.$fb_sh_mem,\”aw\”,%nobits @”))) var
     • __attributo__((allineato(alignbytes)))
   • Configurare l'assegnazione della memoria alla sezione di memoria precedente fb_sh_mem in Progetto > Proprietà > Compilazione C/C++ > Impostazioni MCU mostrate nella Figura 5:
   • Dichiarare la variabile globale g_DTCOPBuf in lvgl_gui_face_rec_cm7.cpp: AT_NONCACHEABLE_SECTION_ALIGN_DTC (uint8_t g_DTCOPBuf[DTC_OPTIMIZE_BUFFER_SIZE], 4);
   • Continua ad aggiungere le definizioni utilizzate nella variabile sopra:
   • Definire la sezione precedente in board_define.h:
     • #define AT_NONCACHEABLE_SECTION_ALIGN_DTC(var, alignbytes) \
     • attributo__((sezione(“.bss.$SRAM_DTC_cm7,\”aw\”,%nobits @”))) var
     • attributo__((allineato(alignbytes)))
   • Includi l'intestazione file hal_vision_algo.h contenente la definizione della macro DTC_OPTIMIZE_BUFFER_SIZE in app_config.h incluso in lvgl_gui_face_rec_cm7.cpp.
7. Imposta la variabile s_debugOption su true per mostrare lo stato di avanzamento del riconoscimento facciale.
8. Aggiungi il percorso di ricerca dell'intestazione files della visione HAL su Progetto > Proprietà > Compilazione C/C++ > Impostazioni > Impostazioni strumento > Compilatore C MCU > Include e compilatore C++ MCU > Include: "${workspace_loc:/${ProjName}/framework/hal/vision}"
9. Aggiungi la definizione seguente per abilitare l'algoritmo di visione HAL in board_define.h: #define ENABLE_VISIONALGO_DEV_Oasis_GUIFaceRec

Abilita l'HAL dell'interfaccia utente di output
L'output UI HAL notifica gli eventi al vision algo HAL e risponde ai risultati dell'inferenza dal vision algo HAL. Con l'app GUI, gli eventi vengono generalmente attivati ​​dall'app e i risultati vengono visualizzati sull'app.

Per abilitarlo, clonare il driver HAL simile esistente file dove generalmente sono implementate le seguenti funzioni:

• Notifica gli eventi per il riconoscimento facciale e l'accesso al database.
• Implementare i callback per l'app GUI per attivare gli eventi.
• Gestisci i risultati dell'inferenza dal modulo algoritmo di visione.
• Mostra il processo e i risultati della gestione degli eventi sull'interfaccia utente tramite la barra di avanzamento controllata con i timer e il rettangolo della guida facciale.

I principali lavori per implementare l'HAL per l'exampi utilizzati in questo documento sono:

• Clonare il driver HAL simile esistente file e modificare i nomi correlati.
• Rimuovi i codici relativi all'app.
• Aggiorna le funzioni per la notifica degli eventi e la risposta ai risultati come ad esampdesign.
• Aggiungi i callback per l'app GUI per attivare gli eventi.

Di seguito i passaggi dettagliati:

1. Clona hal_output_ui_coffee_machine.c. Cambiare il filenome in hal_ output_ui_guifacerec.c.
2. Sostituisci tutte le stringhe CoffeeMachine con GUIFaceRec nel file file.
3. Rimuovi i codici relativi all'app – macchina da caffè.
   • Rimuovere le funzioni WakeUp() e _StandBy() ed i relativi codici (è possibile cercarli nella stringa wake_up e standby).
   • Rimuovi preview eventi in modalità che gestiscono i codici correlati in HAL_OutputDev_UiGUIFaceRec_Input Notify().
   • Rimuovere le funzioni UI_xxx_Callback() e i codici contenenti la stringa gui_ e screen relativi alla GUI della macchina da caffè ad eccezione di gui_set_virtual_face() per il preview funzionalità della modalità.
   • Rimuovere tutti i codici coinvolti con le variabili s_IsWaitingAnotherSelection e s_IsWaitingRegisterSelection relative all'app macchina da caffè.
   • Rimuovi i codici relativi a voce, audio e lingua. Per esampon:
     • #include “hal_voice_algo_asr_local.h”,
     • #include “hal_event_descriptor_voice.h”
4. Per la notifica dei vari eventi, implementare le nuove funzioni _OutputManagerNotify(), _SetFaceRec(), _RegisterGUIFaceRec() e DeregisterGUIFaceRec() facendo riferimento alle funzioni _StopFaceRec(), _RegisterCoffeeSelection() e DeregisterCoffeeSelection() prima di eliminarle.
   • _OutputManagerNotify() implementa la funzione di output dell'evento di base per inviare un evento all'algoritmo di visione HAL. Le funzioni seguenti lo chiamano per inviare i propri eventi.
   • _SetFaceRec() invia l'evento kEventFaceRecID_OasisSetState per attivare l'algoritmo di visione per la registrazione e il riconoscimento dei volti e interrompere l'algoritmo.
   • _RegisterGUIFaceRec() invia l'evento kEventFaceRecId_RegisterGUIFaceRec definito in smart_tlhmi_event_descriptor.h per aggiungere i dati delle caratteristiche del viso al database quando la registrazione è riuscita.
   • DeregisterGUIFaceRec() invia l'evento kEventFaceRecID_DelUser per eliminare i dati delle caratteristiche del volto dal database quando si passa al riconoscimento facciale.
5. Aggiorna i codici per intraprendere le azioni corrispondenti, incluso l'aggiornamento della GUI chiamando le API dall'app GUI LVGL per i risultati di inferenza della registrazione e del riconoscimento dei volti nella funzione _InferComplete_Vision() secondo l'exampla progettazione. Per esample, quando la registrazione del volto ha esito positivo,
   • Smetti di mostrare l'avanzamento chiamando _FaceRecProcess_Stop();
   • Interrompi la registrazione del volto chiamando _SetFaceRec(kOASISLiteState_Stopped);
   • Mostra il risultato positivo sulla GUI: gui_show_face_rec_result(kFaceRecResult_OK, s_UserId);
   • Registrare i dati del volto nel database: _RegisterUserFace(s_UserId);
6. Aggiungi funzioni di callback dell'interfaccia utente per gestire gli eventi: preview, registrazione del volto, riconoscimento ed eliminazione dell'utente attivati ​​dalla GUI. Per esample, la richiamata della registrazione del volto: void UI_Registration_Callback(){ _SetFaceRec(kOASISLiteState_Registration); _FaceRecProcess_Start(); }
   • E aggiungi le funzioni _FaceRecProcess_Start() e _FaceRecProcess_Stop() per mostrare l'avanzamento e lo stato nei diversi eventi e risultati.
   • Aggiorna la funzione di callback ISR del timer _SessionTimer_Callback() per gestire il caso di timeout chiamando: gui_show_face_rec_result(kFaceRecResult_TimeOut, s_UserId);
7. Aggiungi le seguenti definizioni per abilitare l'HAL dell'output dell'interfaccia utente in board_define.h: #define ENABLE_OUTPUT_DEV_UiGUIFaceRec

Avviso:
Per presentare meglio la funzione di riconoscimento facciale, mantenere la funzione per mostrare il processo e i risultati del riconoscimento facciale nell'output dell'HAL dell'interfaccia utente. La funzione è descritta come di seguito

• Il rettangolo della guida del volto diventa blu e la barra di avanzamento mostra l'avanzamento quando si avvia la registrazione o il riconoscimento del volto.
• Il rettangolo della guida del volto diventa rosso quando la registrazione del volto ha esito positivo.
• Il rettangolo della guida facciale diventa verde quando il riconoscimento del volto ha esito positivo.
• Il rettangolo della guida facciale rimane blu e la barra di avanzamento mostra l'avanzamento completo quando l'azione non ha esito positivo dopo la scadenza del timer. A quel punto, interrompi la registrazione o il riconoscimento del volto.

La barra di avanzamento e il rettangolo della guida facciale vengono presentati come icone integrate nel file binario della risorsa file da programmare in Flash. I puntatori ai dati delle icone su SDRAM sono impostati nella funzione LoadIcons(APP_ICONS_BASE) chiamata durante l'inizializzazione del dispositivo HAL dell'interfaccia utente di output nell'HAL dell'interfaccia utente di output. Deve implementare il supporto delle icone per la funzione.

Implementare il supporto delle icone

1. Costruisci la risorsa combinando le icone con le immagini utilizzate nell'app LVGL GUI:
   • Clona l'intestazione delle quattro icone files process_bar_240x14.h, virtual_face_blue_420x426.h, virtual_face_green_420x426.h e virtual_face_red_420x426.h da smart HMI
     \coffee machine\resource\icons\ nelle nuove icone della cartella nella cartella delle risorse dell'example SW.
   • Aggiungi il percorso di ricerca per l'icona quattro files nel camera_preview_risorsa.txt file nella cartella delle risorse, ad esample: icona ../resource/icons/process_bar_240x14.h
   • Esegui camera_preview_resource_build.bat per creare le risorse di immagini e icone per generare il cestino file camera_preview_resource.bin e le informazioni file Resource_information_table.txt (vedere la figura 6).
2. Definire l'indirizzo iniziale su SDRAM e la dimensione delle icone in app_config.h. L'indirizzo inizia accanto alle immagini dell'app GUI. La dimensione viene generata nelle informazioni file. #define APP_ICONS_BASE (APP_RES_SHMEM_BASE + APP_LVGL_IMGS_SIZE) #define APP_ICONS_SIZE 0x107c40
3. Aggiorna la dimensione assegnata della sezione di memoria denominata res_sh_mem a 0x200000 ridefinendola in app_config.h: #define RES_SHMEM_TOTAL_SIZE 0x200000 e l'impostazione corrispondente in Progetto > Proprietà > Build C/C++ > Impostazioni MCU.
4. Aggiungi la dimensione dell'icona alla dimensione totale della risorsa caricata da Flash a SDRAM nella funzione APP_LoadResource() nel main file lvgl_gui_face_rec_cm7.cpp: memcpy((void *)APP_LVGL_IMGS_BASE, pLvglImages, APP_LVGL_IMGS_SIZE + APP_ICONS_SIZE);

Avviso: Per completare la funzione di riconoscimento facciale, è necessario il supporto dell'app LVGL GUI. Le funzioni di callback dell'interfaccia utente nell'HAL dell'interfaccia utente di output vengono chiamate dall'app GUI LVGL per gestire gli eventi dalla schermata dell'interfaccia utente. D'altro canto, l'HAL dell'interfaccia utente di output chiama le API dall'app GUI LVGL per aggiornare l'interfaccia utente per mostrare il risultato e lo stato. Lo sviluppo dell'app LVGL GUI è relativamente indipendente e introdotto nella Sezione 4.3.

4.1.5 Avviare dispositivi e gestori HAL per il riconoscimento facciale
L'algoritmo di visione abilitato HAL e l'output dell'interfaccia utente HAL e i relativi gestori vengono avviati in modalità principale file
lvgl_gui_face_rec_cm7.cpp seguendo le conversioni di sviluppo sul framework come di seguito:

1. Includi l'intestazione file relativi ai due gestori HAL aggiungendo la riga di codice:
   • #include "fwk_output_manager.h"
   • #include “fwk_vision_algo_manager.h”
2. Dichiarare i dispositivi HAL:
   • HAL_VALGO_DEV_DECLARE(OasisGUIFaceRec);
   • HAL_OUTPUT_DEV_DECLARE(UiGUIFaceRec);
3. Registrare i dispositivi HAL:
   • HAL_VALGO_DEV_REGISTER(OasisGUIFaceRec, ret);
   • HAL_OUTPUT_DEV_REGISTER(UiGUIFaceRec, ret);
4. Inizializzare i gestori:
   • FWK_MANAGER_INIT(VisionAlgoManager, ret);
   • FWK_MANAGER_INIT(OutputManager, ret);
5. Iniziano i gestori:
   • FWK_MANAGER_START(VisionAlgoManager, VISION_ALGO_MANAGER_TASK_PRIORITY, ret);
   • FWK_MANAGER_START(OutputManager, OUTPUT_MANAGER_TASK_PRIORITY, ret);
6. Definire la priorità dei compiti del manager:
   • #define VISION_ALGO_MANAGER_TASK_PRIORITY 3
   • #definire OUTPUT_MANAGER_TASK_PRIORITY 1

Aggiunto il supporto del database dei volti sul framework
È possibile accedere ai dati delle caratteristiche del volto registrato nel database dei volti archiviato su Flash tramite un po' file sistema. I passaggi per aggiungere il supporto del database dei volti sono descritti di seguito.

Aggiungi driver per l'archiviazione Flash
Copia il driver FlexSPI dell'interfaccia Flash files fsl_flexspi.c e fsl_flexspi.h e il driver di crittografia dei dati files fsl_caam.c e fsl_caam.h dal percorso SDK_2_13_0_MIMXRT1170-EVK\devices \MIMRX1176\drivers\ alla cartella dei driver dell'example SW.

Aggiungi supporto a livello di consiglio

1. Aggiungi le definizioni di FlexSPI utilizzate per il dispositivo Flash a bordo in board.h:
   • #define BOARD_FLEXSPI FLEXSPI1
   • #define BOARD_FLEXSPI_CLOCK kCLOCK_FlexSpi1
   • #define BOARD_FLEXSPI_AMBA_BASE FlexSPI1_AMBA_BASE
2. Copia gli operatori e le configurazioni files del dispositivo Flash flexspi_nor_flash_ops.c, flexspi_nor_flash_ops.h, sln_flash_config.c, sln_flash_config_w25q256jvs.h, andsln_flash_ops.h nel percorso smart HMI\coffee_machine\cm7\source\flash_config\ nella scheda delle cartelle dell'example SW.
   • Deseleziona "Escludi risorsa dalla build" in C/C++ Build > Impostazioni dopo aver fatto clic con il pulsante destro del mouse su files' e aprendo le Proprietà per consentirne l'integrazione nel progetto.
3. Modifica l'intestazione inclusa filedenominare sln_flash_config.h in sln_flash_config_w25q256jvs.h in sln_flash_config.c e flexspi_nor_flash_ops.h.
4. Imposta la sorgente dell'orologio FlexSPI1 nel file file clock_config.c riferito all'app della macchina da caffè.

Aggiungi adattatore e supporto di livello medio

1. Copia il files sln_flash.c, sln_flash.h, sln_encrypt.c e sln_encrypt.h come driver dell'adattatore per file system e app dal percorso smart HMI\coffee_machine\cm7\source\ alla cartella source dell'example. Aggiorna il nuovo files:
   • Deseleziona "Escludi risorsa dalla creazione" per la creazione.
   • Cambia tutta l'intestazione inclusa file denominare sln_flash_config.h in sln_flash_config_w25q256jvs.h.
2. Copia la cartella filesistema contenente le API per i più piccoli filesystem e driver HAL da smart HMI \coffee_machine\cm7\source\ all'example SW. E aggiorna per la nuova cartella:
   • Deseleziona "Escludi risorsa dalla creazione" per la creazione.
   • Aggiungi il percorso di inclusione nelle impostazioni del progetto: "${workspace_loc:/${ProjName}/filesistema}"
   • Modifica l'intestazione inclusa file denominare sln_flash_config.h in sln_flash_config_w25q256jvs.h e fica_definition.h in app_config.h nel file sln_flash_littlefs.h.
3. Copia la cartella littlefs contenente il middleware – little filesistema dal percorso SDK_2_13_0_ MIMXRT1170-EVK\middleware\ all'example SW. E aggiorna la nuova cartella:
   • Deseleziona "Escludi risorsa dalla creazione" per la creazione.
   • Aggiungi il percorso di inclusione nelle impostazioni del progetto: "${workspace_loc:/${ProjName}/littlefs}"

Aggiungi i driver HAL 

• Esistono due dispositivi HAL: file L'HAL del sistema e del database facciale è supportato per la funzionalità di accesso al database e sono già implementati nel framework senza alcuna modifica. Abilitali aggiungendo le seguenti definizioni in board_define.h:
  • #define ENABLE_FLASH_DEV_Littlefs
  • #definire ENABLE_FACEDB

E cambia il nome del database dei volti per l'example: #define OASIS_FACE_DB_DIR “oasis_gui_face_rec”

Aggiungi supporto a livello di app

1. Aggiorna il principale file lvgl_gui_face_rec_cm7.cpp:
   • Includi l'intestazione file relativo a Flash file gestore HAL del sistema aggiungendo la riga di codice: #include “fwk_flash.h”
   • Dichiarare e registrare file dispositivo HAL del sistema:
     • HAL_FLASH_DEV_DECLARE(Littlefs);
     • HAL_FLASH_DEV_REGISTER(Littlefs, ret);
       Nota: IL file Il dispositivo HAL di sistema deve essere registrato prima che tutti i gestori dispositivi vengano inizializzati nella funzione APP_InitFramework().
   • Chiama la funzione BOARD_ConfigMPU() in APP_BoardInit() per configurare MPU.
2. Imposta il file assegnazione di sistema su Flash nel file file app_config.h definendo le definizioni macro utilizzate nel file file sln_flash_littlefs.h:
   • #definire FICA_IMG_FILE_SYS_ADDR (FLASH_IMG_SIZE + RES_SHMEM_TOTAL_SIZE)
   • #definire FICA_FILE_SYS_SIZE (0x280000)

Configurazioni
Alcuni codici relativi a Flash vengono eseguiti nell'area SRAM ITC per prestazioni sufficienti. Copia la cartella linkscripts contenente le configurazioni del linker dal percorso smart HMI\coffee_machine\cm7\ alla example SW.

Implementare un'app GUI LVGL
Lo sviluppo di un'app GUI LVGL basata sul framework richiama le API dall'output UI HAL e fornisce le API all'output UI HAL (vedere la sezione 4.1.3 per l'implementazione dell'output UI HAL).

Tuttavia, l'implementazione dettagliata di un'app GUI LVGL dipende dai requisiti e dalla progettazione dell'applicazione. L'app GUI in questo example è progettato come descritto all'inizio della sezione Sezione 4.

Di seguito sono riportate le introduzioni all'implementazione:

1. I codici personalizzati sono implementati nei file custom.c e custom.h forniti da GUI Guider come interfaccia tra il progetto GUI Guider e il progetto del sistema incorporato.
   •  Aggiungi le nuove funzioni denominate gui_xxx() in custom.c per ottenere le funzioni seguenti:
     • Per l'HAL dell'interfaccia utente di output e l'app GUI per aggiornare l'interfaccia utente.
     • Per consentire all'app GUI di attivare eventi chiamando le funzioni di callback dell'interfaccia utente dall'HAL dell'interfaccia utente di output.
       Per esempioample, la nuova funzione gui_event_face_rec_action() richiama le funzioni di callback dell'interfaccia utente per gestire uno degli eventi di registrazione del volto, riconoscimento del volto ed eliminazione dell'utente attivati ​​dall'app GUI quando si fa clic sul pulsante correlato.
       Nota: la funzione gui_set_virtual_face() chiamata nell'output dell'interfaccia utente HAL per preview la modalità deve essere implementata in custom.c:
   •  Clona la funzione gui_set_virtual_face() da smart HMI\coffee_machine\cm4\custom \custom.c.
   •  Cambia il nome del widget home_img_cameraPreview su screen_img_camera_preview nella funzione.
   •  Implementa le funzioni di callback dell'interfaccia utente con lo stesso prototipo a tutte quelle nell'output UI HAL sotto il controllo della definizione macro #ifndef RT_PLATFORM in custom.c per essere compatibile con il progetto GUI Guider perché queste funzioni nell'output UI HAL dipendono da piattaforma incorporata. In custom.c, dipendono dal simulatore sulla GUI Guider e sono indipendenti dalla piattaforma incorporata. Per esample, la richiamata della registrazione del volto è implementata come di seguito per il simulatore GUI Guider in esecuzione: #ifndef RT_PLATFORM void UI_Registration_Callback() { gui_hide_del_user_btn(true); s_InAction = falso; ritorno; }
     Nota: Fare riferimento allo stesso prototipo della funzione introdotta al passo 6 della Sezione 4.1.3
     La definizione della macro RT_PLATFORM è impostata nelle impostazioni del progetto di MCUXpresso come mostrato nella Figura 7:
   • Dichiara tutte le funzioni denominate UI_xxx_Callback() e gui_xxx() in custom.h e aggiungi custom.h incluso in smart_tlhmi_event_descriptor.h per condividere le API della GUI nell'HAL di output dell'interfaccia utente.
2. Sviluppare la GUI su GUI Guider:
   • Clona la cartella fotocamera preview contenente il software di progetto GUI Guider nella cartella gui_guider nel pacchetto software di base lvgl_gui_camera_preview_cm7. Modificare il nome correlato camera_preview a face_rec per il nuovo examplui.
   • Copia custom.c e custom aggiornati sopra. h al nuovo software di progetto GUI Guider.
   •  Apri il nuovo progetto face_rec su GUI Guider. Aggiorna come di seguito:
     • Aggiungi il nuovo pulsante etichettato Elimina utente. Aggiungi il flag Nascosto in modo che il pulsante venga nascosto all'avvio dell'app GUI.
     • Aggiungi la riga di codice per chiamare l'API gui_event_face_rec_action() con un parametro ID evento diverso sul trigger "Rilasciato" nell'impostazione evento di tutti i pulsanti Registrazione, Riconoscimento ed Elimina utente per attivare gli eventi di registrazione del volto, riconoscimento del volto ed eliminazione dell'utente. La Figura 8 mostra il codice per l'evento del pulsante Registrazione:
3. Aggiorna il codice generato da GUI Guider al progetto MCUXpresso.
   • Sostituire il contenuto ad eccezione della cartella immagini nella cartella generata dal SW del progetto MCUXpresso con quelli corrispondenti nella cartella generata dal SW del progetto GUI Guider.

Nota: Per maggiori dettagli sulle modifiche sopra introdotte consultare l'esampil software su https://mcuxpresso.nxp.com/appcodehub.

Verifiche con l'exampil progetto

Per ottenere l'example pacchetto software contenente le risorse e gli strumenti per questa nota applicativa, visitare: https://mcuxpresso.nxp.com/appcodehub. Apri l'esample progetto sull'IDE MCUXpresso. Costruisci e programma il file .axf file all'indirizzo 0x30000000 e programmare il contenitore delle risorse file camera_preview_resource.bin all'indirizzo 0x30800000.

Il riconoscimento facciale della GUI LVGL, ad esample funziona normalmente come di seguito:

• Preview: All'accensione, i flussi video catturati dalla telecamera vengono visualizzati nell'area specifica del preamplificatore della telecameraview sullo schermo della GUI. L'etichetta di stato visualizza “Preview…”. Per i dettagli, vedere la Figura 3. Il pulsante Elimina utente è nascosto. Quando si fa clic sull'area esterna ai pulsanti e alle immagini, viene visualizzato il preview dichiarare quanto sopra al termine della registrazione del volto o dell'azione di riconoscimento.
• Registrazione:
  • tartufo: Quando si fa clic sul pulsante Registrazione, viene avviata la registrazione del volto. L'etichetta di stato cambia per visualizzare "Registrazione...", il rettangolo della guida facciale diventa blu e la barra di avanzamento inizia a mostrare l'avanzamento. Assicurati che il volto dell'utente sia visualizzato nel rettangolo blu della guida del volto per la registrazione.
  • successo: L'etichetta di stato mostra "Registrazione...OK" e il numero ID dell'utente registrato, il rettangolo della guida del viso diventa rosso se la registrazione del viso ha esito positivo prima che l'avanzamento venga visualizzato completamente sulla barra.
  • Fallimento -> Timeout: l'etichetta di stato mostra "Registrazione...Timeout" se la registrazione del volto non è ancora riuscita quando lo stato di avanzamento è pieno sulla barra.
  • Errore -> Duplicazione: l'etichetta di stato mostra "Registrazione...Non riuscita", il rettangolo della guida del volto diventa verde se il volto registrato viene riconosciuto prima che l'avanzamento venga visualizzato completamente sulla barra.
• iconoscimento:
  • Avvio: quando si fa clic sul pulsante Riconoscimento, viene avviato il riconoscimento del volto. L'etichetta di stato cambia per visualizzare "Riconoscimento...", il rettangolo della guida facciale diventa blu e la barra di avanzamento inizia a mostrare l'avanzamento. Assicurati che il volto dell'utente sia mostrato nel rettangolo blu della guida del volto per la registrazione.
  • successo: L'etichetta di stato mostra "Riconoscimento...OK" e il numero ID utente riconosciuto, il rettangolo della guida facciale diventa verde se il riconoscimento facciale ha esito positivo prima che l'avanzamento venga visualizzato completamente sulla barra. A questo punto viene visualizzato il pulsante Elimina utente. Ciò significa che l'utente può essere eliminato solo quando viene riconosciuto.
  • soccorso: L'etichetta di stato mostra "Riconoscimento...Timeout" se il riconoscimento del volto non è ancora riuscito quando lo stato di avanzamento è pieno sulla barra.
• Elimina utente: Quando si fa clic sul pulsante "Elimina utente", dopo che il riconoscimento del volto ha avuto esito positivo, l'etichetta di stato cambia per visualizzare "Elimina utente...OK" con il rettangolo della guida facciale che diventa blu e l'avanzamento viene visualizzato pieno sulla barra. Il pulsante Elimina utente è nuovamente nascosto. Il volto/utente riconosciuto viene eliminato dal database. Ciò significa che questo volto/utente non potrà essere riconosciuto finché non verrà nuovamente registrato.

Nota sul codice sorgente nel documento
Exampil codice mostrato in questo documento ha il seguente copyright e licenza BSD-3-Clause:

Copyright 2024 NXP La ridistribuzione e l'uso in formato sorgente e binario, con o senza modifiche, sono consentiti a condizione che siano soddisfatte le seguenti condizioni:

1. Le ridistribuzioni del codice sorgente devono conservare la suddetta nota di copyright, il presente elenco di condizioni e la seguente clausola di esclusione di responsabilità.
2. Le ridistribuzioni in formato binario devono riprodurre l'avviso di copyright di cui sopra, questo elenco di condizioni e il seguente disclaimer nella documentazione e/o altri materiali devono essere forniti con la distribuzione.
3. Né il nome del detentore del copyright né i nomi dei suoi contributori possono essere utilizzati per sostenere o promuovere prodotti derivati ​​da questo software senza previa autorizzazione scritta specifica

QUESTO SOFTWARE VIENE FORNITO DAI TITOLARI DEL COPYRIGHT E DAI COLLABORATORI "COSÌ COM'È" E QUALSIASI GARANZIA ESPLICITA O IMPLICITA, COMPRESE, SENZA LIMITAZIONI, LE GARANZIE IMPLICITE DI COMMERCIABILITÀ E IDONEITÀ PER UNO SCOPO PARTICOLARE, È ESCLUSA. IN NESSUN CASO IL TITOLARE DEL COPYRIGHT O I COLLABORATORI SARANNO RITENUTI RESPONSABILI PER QUALSIASI DANNO DIRETTO, INDIRETTO, ACCIDENTALE, SPECIALE, ESEMPLARE O CONSEGUENTE (INCLUSI, SENZA LIMITAZIONE, L'ACQUISTO DI BENI O SERVIZI SOSTITUTIVI; LA PERDITA DI UTILIZZO, DATI O PROFITTI; O L'INTERRUZIONE DELL'ATTIVITÀ) COMUNQUE CAUSATO E IN BASE A QUALSIASI TEORIA DI RESPONSABILITÀ, SIA PER CONTRATTO, RESPONSABILITÀ OGGETTIVA O ILLECITO CIVILE (INCLUSA NEGLIGENZA O ALTRO) DERIVANTE IN QUALSIASI MODO DALL'UTILIZZO DI QUESTO SOFTWARE, ANCHE SE INFORMATI DELLA POSSIBILITÀ DI TALE DANNO.

Cronologia delle revisioni

Informazioni legali

Definizioni
Bozza: lo stato di bozza di un documento indica che il contenuto è ancora in fase di revisione interna.view e soggetto ad approvazione formale, che può comportare modifiche o aggiunte. NXP Semiconductors non fornisce alcuna dichiarazione o garanzia circa l'accuratezza o la completezza delle informazioni incluse in una versione bozza di un documento e non avrà alcuna responsabilità per le conseguenze dell'uso di tali informazioni.

Disclaimer

• Garanzia limitata e responsabilità — Le informazioni contenute in questo documento sono ritenute accurate e affidabili. Tuttavia, NXP Semiconductors non fornisce alcuna dichiarazione o garanzia, espressa o implicita, in merito all'accuratezza o alla completezza di tali informazioni e non si assume alcuna responsabilità per le conseguenze dell'uso di tali informazioni. NXP Semiconductors non si assume alcuna responsabilità per il contenuto di questo documento se fornito da una fonte di informazioni al di fuori di NXP Semiconductors.
  In nessun caso NXP Semiconductors potrà essere ritenuta responsabile per eventuali danni indiretti, incidentali, punitivi, speciali o consequenziali (inclusi, a titolo esemplificativo, mancato guadagno, mancato risparmio, interruzione dell'attività, costi relativi alla rimozione o sostituzione di qualsiasi prodotto o spese di rilavorazione) indipendentemente dal fatto che o meno, tali danni sono basati su illecito (inclusa negligenza), garanzia, violazione del contratto o qualsiasi altra teoria legale.
  Nonostante eventuali danni che il cliente potrebbe subire per qualsiasi motivo, la responsabilità aggregata e cumulativa di NXP Semiconductors nei confronti del cliente per i prodotti qui descritti sarà limitata in conformità con i Termini e le condizioni di vendita commerciale di NXP Semiconductors.
• Diritto di apportare modifiche — NXP Semiconductors si riserva il diritto di apportare modifiche alle informazioni pubblicate in questo documento, incluse, a titolo esemplificativo, le specifiche e le descrizioni dei prodotti, in qualsiasi momento e senza preavviso. Il presente documento sostituisce e sostituisce tutte le informazioni fornite prima della pubblicazione del presente documento.
• Idoneità all'uso — I prodotti NXP Semiconductors non sono progettati, autorizzati o garantiti per essere idonei all'uso in sistemi o apparecchiature di supporto vitale, critici per la vita o per la sicurezza, né in applicazioni in cui è ragionevolmente prevedibile che il guasto o il malfunzionamento di un prodotto NXP Semiconductors provochino lesioni personali, morte o gravi danni materiali o ambientali. NXP Semiconductors ei suoi fornitori non si assumono alcuna responsabilità per l'inclusione e/o l'uso dei prodotti NXP Semiconductors in tali apparecchiature o applicazioni e pertanto tale inclusione e/o utilizzo è a rischio e pericolo del cliente.
• Applicazioni — Le applicazioni qui descritte per uno qualsiasi di questi prodotti sono solo a scopo illustrativo. NXP Semiconductors non rilascia alcuna dichiarazione o garanzia che tali applicazioni siano adatte all'uso specificato senza ulteriori test o modifiche.
  I clienti sono responsabili della progettazione e del funzionamento delle loro applicazioni e dei prodotti che utilizzano i prodotti NXP Semiconductors e NXP Semiconductors non si assume alcuna responsabilità per qualsiasi assistenza con le applicazioni o la progettazione dei prodotti dei clienti. È esclusiva responsabilità del cliente determinare se il prodotto NXP Semiconductors è adatto e adatto alle applicazioni e ai prodotti pianificati del cliente, nonché all'applicazione pianificata e all'utilizzo da parte di clienti terzi del cliente. I clienti devono fornire adeguate misure di protezione operativa e progettuale per ridurre al minimo i rischi associati alle loro applicazioni e prodotti. NXP Semiconductors non si assume alcuna responsabilità relativa a eventuali inadempienze, danni, costi o problemi basati su eventuali debolezze o inadempienze nelle applicazioni o nei prodotti del cliente o nell'applicazione o nell'utilizzo da parte di clienti terzi del cliente. Il cliente è responsabile dell'esecuzione di tutti i test necessari per le applicazioni e i prodotti del cliente che utilizzano i prodotti NXP Semiconductors al fine di evitare un'inadempienza delle applicazioni e dei prodotti o dell'applicazione o l'utilizzo da parte di clienti terzi del cliente. NXP non si assume alcuna responsabilità al riguardo.
• Termini e condizioni di vendita commerciale — I prodotti NXP Semiconductors sono venduti soggetti ai termini e alle condizioni generali di vendita commerciale, pubblicati su https://www.nxp.com/profile/termini, salvo diverso accordo scritto individuale. In caso di conclusione di un accordo individuale si applicano solo i termini e le condizioni del rispettivo accordo. NXP Semiconductors si oppone espressamente all'applicazione dei termini e delle condizioni generali del cliente per quanto riguarda l'acquisto di prodotti NXP Semiconductors da parte del cliente.
• Controllo delle esportazioni — Questo documento e gli articoli qui descritti possono essere soggetti a normative sul controllo delle esportazioni. L'esportazione potrebbe richiedere un'autorizzazione preventiva da parte delle autorità competenti.
• Idoneità all'uso in prodotti qualificati non automobilistici — A meno che questo documento non affermi espressamente che questo specifico prodotto NXP Semiconductors è qualificato per il settore automobilistico, il prodotto non è adatto all'uso automobilistico. Non è né qualificato né testato in conformità ai test automobilistici o ai requisiti applicativi. NXP Semiconductors non si assume alcuna responsabilità per l'inclusione e/o l'uso di prodotti qualificati non automobilistici in apparecchiature o applicazioni automobilistiche.
  Nel caso in cui il cliente utilizzi il prodotto per la progettazione e l'uso in applicazioni automobilistiche in base a specifiche e standard automobilistici, il cliente (a) dovrà utilizzare il prodotto senza la garanzia del prodotto di NXP Semiconductors per tali applicazioni, usi e specifiche automobilistiche e ( b) ogni volta che il cliente utilizza il prodotto per applicazioni automobilistiche al di fuori delle specifiche di NXP Semiconductors, tale uso sarà esclusivamente a proprio rischio e (c) il cliente indennizza completamente NXP Semiconductors per qualsiasi responsabilità, danno o reclamo sul prodotto non riuscito risultante dalla progettazione e dall'uso del il prodotto per applicazioni automobilistiche oltre la garanzia standard di NXP Semiconductors e le specifiche di prodotto di NXP Semiconductors.
• Traduzioni — Una versione non inglese (tradotta) di un documento, comprese le informazioni legali in quel documento, è solo di riferimento. La versione inglese prevarrà in caso di discrepanza tra la versione tradotta e quella inglese.
• Sicurezza — Il Cliente comprende che tutti i prodotti NXP possono essere soggetti a vulnerabilità non identificate o possono supportare standard o specifiche di sicurezza consolidati con limitazioni note. Il Cliente è responsabile della progettazione e del funzionamento delle sue applicazioni e dei suoi prodotti durante il loro ciclo di vita per ridurre l'effetto di queste vulnerabilità sulle applicazioni e sui prodotti del cliente. La responsabilità del cliente si estende anche ad altre tecnologie aperte e/o proprietarie supportate dai prodotti NXP per l'utilizzo nelle applicazioni del cliente. NXP non si assume alcuna responsabilità per eventuali vulnerabilità. Il cliente deve controllare regolarmente gli aggiornamenti di sicurezza da NXP e seguirli in modo appropriato. Il Cliente deve selezionare i prodotti con caratteristiche di sicurezza che soddisfano al meglio le regole, i regolamenti e gli standard dell'applicazione prevista e prendere le ultime decisioni di progettazione relative ai propri prodotti ed è l'unico responsabile della conformità a tutti i requisiti legali, normativi e relativi alla sicurezza relativi ai propri prodotti, indipendentemente di qualsiasi informazione o supporto che possa essere fornito da NXP.

NXP dispone di un Product Security Incident Response Team (PSIRT) (raggiungibile all'indirizzo PSIRT@nxp.com) che gestisce l'indagine, la segnalazione e il rilascio della soluzione alle vulnerabilità di sicurezza dei prodotti NXP.
NXP BV — NXP BV non è una società operativa e non distribuisce né vende prodotti.

Marchi
Avviso: Tutti i marchi, i nomi dei prodotti, i nomi dei servizi e i marchi citati sono di proprietà dei rispettivi proprietari.

NXP — il marchio denominativo e il logo sono marchi di NXP BV

AMBA, Arm, Arm7, Arm7TDMI, Arm9, Arm11, Artisan, big.LITTLE, Cordio, CoreLink, CoreSight, Cortex, DesignStart, DynamIQ, Jazelle, Keil, Mali, Mbed, Mbed abilitato, NEON, POP, RealView, SecurCore, Socrates, Thumb, TrustZone, ULINK, ULINK2, ULINK-ME, ULINK-PLUS, ULINKpro, μVision, Versatile — sono marchi e/o marchi registrati di Arm Limited (o delle sue consociate o affiliate) negli Stati Uniti e/o altrove. La relativa tecnologia può essere protetta da uno o tutti i brevetti, diritti d'autore, design e segreti commerciali. Tutti i diritti riservati.

• i.MX— è un marchio di NXP BV
• J Link — è un marchio di SEGGER Microcontroller GmbH.

Microsoft, Azure e ThreadX sono marchi del gruppo di società Microsoft.

Si prega di notare che avvisi importanti riguardanti il ​​presente documento e i prodotti in esso descritti sono stati inclusi nella sezione "Informazioni legali".

Italiano:
Per maggiori informazioni, visitare: https://www.nxp.com

• Data di rilascio: 19 aprile 2024
• Identificatore del documento: AN14263

Domande frequenti

D: Qual è lo scopo principale di questo prodotto?
R: Lo scopo principale è abilitare la funzione di riconoscimento facciale utilizzando un modello di algoritmo di visione AI&ML con una semplice GUI LVGL example sulla scheda SLN-TLHMI-IOT.

D: In che modo gli sviluppatori possono trarre vantaggio da questa nota applicativa?
R: Gli sviluppatori possono imparare come implementare il riconoscimento facciale sul framework passo dopo passo utilizzando l'example e comprendere i gestori dei dispositivi, i dispositivi HAL e i meccanismi degli eventi coinvolti.

Documenti / Risorse

NXP AN14263 Implementa il riconoscimento facciale della GUI LVGL su Framewor [pdf] Guida utente AN14263 Implementa il riconoscimento facciale della GUI LVGL su Framewor, AN14263, Implementa il riconoscimento facciale della GUI LVGL su Framewor, Riconoscimento facciale della GUI LVGL su Framewor, Riconoscimento facciale su Framewor, Riconoscimento su Framewor, Framewor

Riferimenti

• Manuale d'uso