NXP AN14263 Implementera LVGL GUI Ansiktsigenkänning på Framewor

Produktinformation

Specifikationer

• Produktnamn: LVGL GUI Ansiktsigenkänning på Framework
• Dokumentrevision: 1–19 april 2024
• Nyckelord: Ansiktsigenkänning, LVGL GUI, Framework

Produktanvändningsinstruktioner

1. Överview
   Denna produkt möjliggör AI&ML-visionalgoritmmodell för ansiktsigenkänning på ett ramverk för att implementera ansiktsigenkänningsfunktion med ett enkelt LVGL GUI ex.ample på SLN-TLHMI-IOT-kortet.
2. Ram överview
   Lösningsmjukvaran är designad kring ramverksarkitekturen som inkluderar enhetshanterare som ansvarar för att hantera enheter, HAL-enheter för att abstrahera underliggande detaljer och händelser för kommunikation mellan olika enheter.
3. Drag
   Produkten möjliggör implementering av ansiktsigenkänningsfunktion via kamerapreview på GUI-skärmen med knappar för att aktivera ansiktsregistrering, igenkänning och borttagning. Registrerad ansiktsdata lagras på Flash via en file system.
4. Applikationsanteckningsinnehåll
   Applikationsanteckningen presenterar en LVGL GUI-skärm med kamerapreview och knappar för ansiktsrelaterade åtgärder. Det hjälper utvecklare att förstå ramverket och hur man implementerar ansiktsigenkänning med hjälp av example.

Överview

NXP har lanserat ett lösningsutvecklingskit vid namn SLN-TLHMI-IOT som fokuserar på smarta HMI-applikationer. Det möjliggör smart HMI med ML vision, röst och grafik UI implementerat på en NXP i.MX RT117H MCU. Baserat på SDK:n är lösningsmjukvaran konstruerad på en design som kallas ramverk som stöder flexibla konstruktioner och anpassning av vision och röstfunktioner. För att hjälpa användare att använda mjukvaruplattformen bättre tillhandahålls vissa grundläggande dokument, t.example, användarhandboken för mjukvaruutveckling. Guiden introducerar den grundläggande mjukvarudesignen och arkitekturen för applikationerna som täcker alla komponenter i lösningen inklusive ramverket för att hjälpa utvecklarna enklare och effektivt implementera sina applikationer med SLN-TLHMI-IOT.
För mer information om lösningen och relevanta dokument, besök web sida av NXP EdgeReady Smart HMI-lösning Baserad på i.MX RT117H med ML Vision, Voice och grafiskt UI. Det är dock fortfarande inte så lätt för utvecklarna att implementera sina smarta HMI-applikationer med hänvisning till dessa grundläggande guider. En serie ansökningsnoteringar planeras för att hjälpa till att studera utvecklingen av ramverket steg för steg. Denna anmärkning är baserad på Implement LVGL GUI Camera Preview om ramverk (dokument AN14147). Denna applikationsnotering beskriver hur du aktiverar AI&ML-visionalgoritmmodellen för ansiktsigenkänning på ramverket för att implementera ansiktsigenkänningsfunktionen via kameraföreview på GUI-skärmen med ett enkelt LVGL GUI example på SLN-TLHMI-IOT-kortet. I ansökningsanteckningen har example presenterar en LVGL GUI-skärm med en kamerapreview och några knappar för att aktivera ansiktsregistrering, igenkänning och borttagning. Den registrerade ansiktsdata lagras på Flash via lite file system.

På hög nivå innehåller ansökningsnotisen följande innehåll:

• Aktivera ansiktsigenkänningsfunktionen på ramverket.
• Lägg till ansiktsdatabasstöd på ramverket via file system på Flash.
• Implementera LVGL GUI-appen. Genom ovanstående introduktioner hjälper detta dokument utvecklarna att:
• Förstå ramverket och programvaran för smarta HMI-lösningar djupare.
• Utveckla deras AI&ML-ansiktsigenkänning på ramverk med LVGL GUI-appen.

Ramen överview
Lösningsmjukvaran är i första hand designad kring användningen av ramarkitekturen som är sammansatt av flera olika delar:

• Enhetshanterare – kärnan
• Hardware Abstraction Layer (HAL)-enheter
• Meddelanden/Händelser

Som visas i figur 1, överview av ramverkets mekanism är:

Enhetshanterare ansvarar för att hantera enheter som används av systemet. Varje enhetstyp (ingång, utgång och så vidare) har sin egen typspecifika enhetshanterare. Med en enhetshanterare som startar efter att enheterna har registrerats till den, väntar den och kontrollerar ett meddelande för att överföra data till enheterna och andra hanterare efter initialisering och start av de registrerade enheterna. HAL-enheterna är skrivna ovanpå drivrutinskoden på lägre nivå, vilket hjälper till att öka kodens förståelse genom att abstrahera många av de underliggande detaljerna.

Händelser är ett sätt genom vilket information kommuniceras mellan olika enheter via deras chefer. När en händelse utlöses kommunicerar enheten som först tog emot händelsen den händelsen till sin chef, och i sin tur meddelar den andra chefer som är utsedda att ta emot händelsen.

Den arkitektoniska utformningen av ramverket var centrerad på tre primära mål:

1. Enkel att använda
2. Flexibilitet/bärbarhet
3. Prestanda

Ramverket är utformat med målet att påskynda tiden till marknaden för vision och andra maskininlärningsapplikationer. För att säkerställa en snabb tid till marknaden är det avgörande att själva programvaran är lätt att förstå och modifiera. Med detta mål i åtanke är ramverkets arkitektur lätt att modifiera utan att vara restriktiv och utan att gå på bekostnad av prestanda.
För mer information om ramverket, se Smart HMI Software Development User Guide (dokument MCU-SMHMI-SDUG).

Lätt och mångsidigt grafikbibliotek (LVGL)
LVGL (Light and Versatile Graphics Library) är ett gratis grafikbibliotek med öppen källkod som tillhandahåller allt du behöver för att skapa ett inbäddat GUI med lättanvända grafiska element, vackra visuella effekter och lågt minnesutrymme.

GUI Guider
GUI Guider är ett användarvänligt utvecklingsverktyg för grafiskt användargränssnitt från NXP som möjliggör snabb utveckling av högkvalitativa skärmar med LVGL-grafikbiblioteket med öppen källkod. GUI Guiders dra-och-släpp-redigerare gör det enkelt att använda många funktioner i LVGL som widgets, animationer och stilar för att skapa ett GUI med minimal eller ingen kodning alls.

Med ett klick på en knapp kan du köra din applikation i en simulerad miljö eller exportera den till ett målprojekt. Genererad kod från GUI Guider kan enkelt läggas till i ditt projekt, vilket påskyndar utvecklingsprocessen och låter dig sömlöst lägga till ett inbäddat användargränssnitt till din applikation. GUI Guider är gratis att använda med NXP:s MCU för allmänna ändamål och crossover och inkluderar inbyggda projektmallar för flera plattformar som stöds. För att lära dig mer om LVGL och GUI-utveckling på GUI Guider, kolla Light and Versatile Graphics Library och GUI Guider.

Utvecklingsmiljö

Förbered först och ställ in hård- och mjukvarumiljön för att implementera example på ramarna.

Hårdvarumiljö
Hårdvarumiljön är inställd för att verifiera exampde:

• Det smarta HMI-utvecklingspaketet baserat på NXP i.MX RT117H (SLN_TLHMI_IOT-satsen)
• SEGGER J-Link med en 9-stifts Cortex-M-adapter och V7.84a eller en nyare version av drivrutinen

Programvarumiljö
Mjukvarumiljön är inställd för att utveckla exampde:

• MCUXpresso IDE V11.7.0
• GUI Guider V1.6.1-GA
• lvgl_gui_camera_preview_cm7 – exampkoden för den andra applikationsnoten som basprogramvara för utvecklingen. För detaljer, se https://mcuxpresso.nxp.com/appcodehub.
• RT1170 SDK V2.13.0 – som kodresurs för utvecklingen.
• SLN-TLHMI-IOT-programvara V1.1.2 – smart HMI-källkod släppt på NXP GitHub-förvaret som kodresurs för utvecklingen. För detaljer, se: GitHub – NXP/mcu-smhmi at v1.1.2

För detaljer om anskaffning och installation av mjukvarumiljön, se: Komma igång med SLN-TLHMI-IOT.

Visionsarkitektur på ramverk

Visionsarkitekturen på ramverket visas i figur 2. Visionsalgo HAL (OASIS_HAL) har följande processer:

• Gör ansiktsregistrering och igenkänning genom AI&ML-visionalgoritmmodellen efter att ha tagit emot relaterade händelser från utdata-UI HAL. Meddela slutledningsresultaten från algoritmmodellen till utdata-UI HAL.
• Åtkomst till (lägg till, ta bort...) ansiktsfunktionsdatabasen baserat på det lilla file system genom att anropa API:erna för FaceDB HAL efter att ha mottagit relaterade händelser från utdata-UI HAL.
• Begär kamerans videoram från kamerans HAL när du gör ansiktsregistrering och igenkänning.

Implementera ansiktsigenkänning på ramverket

LVGL GUI ansiktsigenkänning example (example tillhandahålls senare) på ramverket implementeras baserat på example-koder för Implement LVGL GUI Camera Preview om ramverk (dokument AN14147).

För att demonstrera ansiktsigenkänningen i example, den grundläggande funktionen för GUI-appen (se huvudskärmen i figur 3) är utformad enligt beskrivningen nedan:

• GUI-appen utlöser ansiktsregistrering eller igenkänningshändelse till utdata-UI HAL när du klickar på knappen Registrering eller igenkänning. Och utdata UI HAL meddelar händelsen att en användare läggs till i vision algo HAL efter att ansiktsregistreringen har lyckats.
• GUI-appen utlöser händelsen att en användare raderas till utdata-UI HAL när du klickar på knappen Ta bort användare efter att användarens ansikte har identifierats.
• GUI-appen utlöser händelsen av att stoppa oasis-algo som körs till utgångens UI HAL när du klickar på skärmen utanför knapparna och bilderna.

Förbered mjukvarupaketet för implementeringen av example.

• Klona basprogramvaran lvgl_gui_camera_preview_cm7. Ändra projektnamn och huvud filenamn till lvgl_gui_face_rec_cm7.
• Ramverket behövs för att uppdateras i mjukvaran eftersom källkoderna för ramverkets kärna har börjat vara offentliga på GitHub från version 1.1.2.
• Ersätt rammappen med kopian av V1.1.2 från GitHub med undantag för files fwk_log.h och fwk_common.h under inc\ eftersom de har modifierats för serien av applikationsnoteringar. Operationerna visas i figur 4:
• Ta bort mappen framework_cm7 under gruppen libs och ta bort biblioteket framework_cm7 och dess sökväg konfigurerad i Projekt > Egenskaper > C/C++ Build > inställningar > Verktygsinställningar > MCU C++ Linker > Bibliotek eftersom källkoden för kärnan tillhandahålls.

Aktivera ansiktsigenkänningsfunktionen på ramverket
Ansiktsigenkänningsfunktionen är byggd på ML-visionalgoritmmodellen som tillhandahålls som ett statiskt bibliotek – ett oasis lite runtime-bibliotek av NXP. Biblioteket är ett litet, mycket effektivt, anpassat och optimerat AI-bibliotek. Modellen inkluderar ansiktsigenkänning, ansiktsigenkänning, glasdetektering och livlighetsdetektering. Det tillhandahåller huvudsakligen API:et OASISLT_run_extended() för att köra ansiktsigenkänningspipelinen samtidigt som resultat uppdateras till den som ringer genom händelseåterkallningar, och lägga till/uppdatera/ta bort ansikten i databasen genom ansiktsdatabasens återanrop efter att ha specificerat källramsinformation, återuppringningar och minne pool som används av biblioteket genom att anropa ett annat API OASISLT_init() vid initiering. Anropet av API:erna och callback-funktionerna implementeras i ramverkets vision algo HAL.

Lägg till vision algo modellbibliotek

1. Kopiera mappoas som innehåller biblioteket och den relaterade rubriken file från smart HMI\coffee_machine\cm7\libs\ till mappen libs i example SW.
2. Lägg till sökvägen för rubriken file i Projekt > Egenskaper > C/C++ Bygg > inställningar > Verktygsinställningar > MCU C kompilator > Inkluderar och MCU C++ kompilator > Inkluderar: "${workspace_loc:/${ProjName}/libs/oasis/include}"
3. Lägg till lib och dess sökväg på Project > Properties > C/C++ Build > Settings > MCU C+ + Linker > Libraries: liboasis_lite2D_DEFAULT_117f_ae.a “${workspace_loc:/${ProjName}/libs/oasis}” och makrodefinitionen för att aktivera funktionen på Projekt > Egenskaper > C/C++ Bygg > inställningar > Verktygsinställningar > MCU C-kompilator > Preprocessor och MCU C++-kompilator > Preprocessor: SMART_TLHMI_2D

Aktivera vision algo HAL
Vision algo HAL driver vision algo-modellen att fungera och svarar resultaten på UI-utgången HAL efter att ha tagit emot händelserna från den.

För att aktivera det, klona den existerande liknande HAL-drivrutinen file där nedanstående funktioner är implementerade:

• Implementera callbacks av ansiktsdatabasoperationer och händelsehantering.
• Få visionen att fungera genom att anropa API:erna för oasisbiblioteket.
• Få åtkomst till användaransiktsdatabas och appdatabas (det behövs inte i example).
• Ta emot händelser från och skicka resultat till utdata UI HAL.

De stora arbetena för att implementera HAL för exampde är:

• Klona den existerande liknande HAL-drivrutinen file och ändra relaterade namn.
• Ta bort koderna relaterade till appens dataoperationer.
• Uppdatera definitionerna och funktionerna för att hantera händelserna från utdata-UI HAL enligt exampdesignen.
• Lägg till de konfigurationer som krävs i oasisinitiering.

De detaljerade stegen är som följer:

1. Klona hal_vision_algo_oasis_kaffemaskin.c. Ändra filenamn till hal_vision_algo_oasis_guifacerec.c. Och byt ut alla strängar CoffeeMachine med GUIFaceRec i file.
2. Ta bort koderna som innehåller strängen coffeedb (inte skiftlägeskänslig) relaterade till appdatabasen, till exempelample, #inkludera hal_sln_coffeedb.h.
3. Ändra funktionen HAL_VisionAlgoDev_OasisGUIFaceRec_InputNotify() för att hantera händelserna från utdata-UI HAL.
   • Ändra händelsedefinitionen kEventFaceRecId_RegisterCoffeeSelection till kEventFaceRecId_RegisterUserFace och struktursträngen regCoffeeSelection till regGUIFaceRec för att händelsehanteringen ska lägga till nya ansiktsfunktionsdata till databasen.
   • För att visa standardprocessen för ansiktsigenkänningsåtgärderna i example, ändra hanteringen i fallet med kEventFaceRecID_OasisSetState med definitionerna av tillstånden:
     • kOASISLiteState
     • Registrering kOASISLiteState
     • Igenkänning kOASISLiteState
     • Slutade
4. Lägg till och ändra definitionerna av händelserna som nämns i steget ovan.
   • Kopiera rubriken file smart_tlhmi_event_descriptor.h från smart HMI\coffee_machine \cm7\source\event_handlers\ till mappkällan för exetample SW. Uppdatera file enligt nedan:
   • Ändra händelsedefinitionen kEventFaceRecId_RegisterCoffeeSelection till kEventFaceRecId_RegisterUserFace i enumtypen _event_smart_tlhmi_id och struktursträngen regCoffeeSelection till regGUIFaceRec i strukturen _event_smart_tlhmi. Så ändra strukturen register_coffee_selection_event_t för regCoffeeSelection till register_gui_facerec_event_t.
   • Ta bort det övriga innehållet som används för kaffemaskinsappen, till exempelample, kodraden om röst: #include “hal_event_descriptor_voice.h”.
   • Lägg till typerna kOASISLiteState_Stopped och kOASISLiteState_Running till enumtypen oasis_lite_state_t i hal_vision_algo.h under framework>hal>vision i projektet enligt nedan:
     typedef enum _oasis_lite_state {
     • kOASISLiteState
     • Körs, kOASISLiteState
     • Stoppad, kOASISLiteState
     • Erkännande,
     • kOASISLiteState
     • Registrering, kOASISLiteState
     • Avregistrering, kOASISLiteState
     • RemoteRegistration, kOASISLiteState
     • Räkna
   • Använd ovanstående uppdaterade struct oasis_lite_state_t för att förfina struct oasis_state_event_t i hal_event_descriptor_face_rec.h under framework>hal>vision i projektet enligt nedan: typedef struct _oasis_state_event_t { oasis_lite_state_t state; } oasis_state_event_t;
5. Ändra alla kEventInfo_Remote till kEventInfo_Local för att skicka händelser från vision algo HAL till andra HAL som körs på samma kärna som enkelkärna istället för dual-core används i example.
6. Lägg till och ändra nedanstående konfigurationer för oasisinitiering i OASISLT_init():
   • Lägg till makrodefinitioner och minnessektioner för videoramen i 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__((sektion(“.bss.$fb_sh_mem,\”aw\”,%nobits @”))) var
     • __attribute__((aligned(alignbytes)))
   • Konfigurera minnestilldelningen till ovanstående minnessektion fb_sh_mem på Projekt > Egenskaper > C/C++ Bygg > MCU-inställningar som visas i figur 5:
   • Deklarera den globala variabeln g_DTCOPBuf i lvgl_gui_face_rec_cm7.cpp: AT_NONCACHEABLE_SECTION_ALIGN_DTC (uint8_t g_DTCOPBuf[DTC_OPTIMIZE_BUFFER_SIZE], 4);
   • Fortsätt att lägga till definitionerna som används i variabeln ovan:
   • Definiera avsnittet ovan i board_define.h:
     • #define AT_NONCACHEABLE_SECTION_ALIGN_DTC(var, alignbytes) \
     • attribut__((sektion(“.bss.$SRAM_DTC_cm7,\”aw\”,%nobits @”))) var
     • attribut__((aligned(alignbytes)))
   • Inkludera rubriken file hal_vision_algo.h som innehåller makrodefinitionen DTC_OPTIMIZE_BUFFER_SIZE i app_config.h inkluderad i lvgl_gui_face_rec_cm7.cpp.
7. Ställ in variabeln s_debugOption till true för att visa framstegsstatus vid ansiktsigenkänning.
8. Lägg till sökvägen för rubriken files av vision HAL på projekt > Egenskaper >C/C++ Bygg > inställningar > Verktygsinställningar > MCU C kompilator > Inkluderar och MCU C++ kompilator > Inkluderar: "${workspace_loc:/${ProjName}/framework/hal/vision}"
9. Lägg till definitionen nedan för att aktivera vision algo HAL i board_define.h: #define ENABLE_VISIONALGO_DEV_Oasis_GUIFaceRec

Aktivera utgång UI HAL
Utdata UI HAL meddelar händelserna till vision algo HAL och svarar på slutledningsresultaten från vision algo HAL. Med GUI-appen utlöses händelserna i allmänhet av appen och resultaten visas i appen.

För att aktivera det, klona den existerande liknande HAL-drivrutinen file där i allmänhet nedanstående funktioner är implementerade:

• Meddela händelserna för ansiktsigenkänning och databasåtkomst.
• Implementera callbacks för GUI-appen för att utlösa händelserna.
• Hantera slutledningsresultaten från vision algo-modulen.
• Visa processen och resultaten av händelsehanteringen i användargränssnittet av förloppsindikatorn som styrs med timers och rektangeln för ansiktsguiden.

De stora arbetena för att implementera HAL för exampDe som används i detta dokument är:

• Klona den existerande liknande HAL-drivrutinen file och ändra relaterade namn.
• Ta bort koderna relaterade till appen.
• Uppdatera funktionerna för händelsemeddelanden och resultatsvar enligt exampdesignen.
• Lägg till återuppringningar för GUI-appen för att utlösa händelserna.

De detaljerade stegen är som följer:

1. Klona hal_output_ui_coffee_machine.c. Ändra filenamn till hal_ output_ui_guifacerec.c.
2. Byt ut alla strängar CoffeeMachine med GUIFaceRec i file.
3. Ta bort koderna relaterade till appen – kaffemaskin.
   • Ta bort funktionerna WakeUp() och _StandBy() och de relaterade koderna (kan söka i strängen wake_up och standby efter dem).
   • Ta bort preview lägeshändelser som hanterar relaterade koder i HAL_OutputDev_UiGUIFaceRec_Input Notify().
   • Ta bort funktionerna UI_xxx_Callback() och koderna som innehåller strängen gui_ och skärm relaterade till kaffemaskinens GUI förutom gui_set_virtual_face() för preview lägesfunktion.
   • Ta bort alla koder som är involverade i variablerna s_IsWaitingAnotherSelection och s_IsWaitingRegisterSelection relaterade till kaffemaskinsappen.
   • Ta bort koderna för röst, ljud och språk. Till exempelampde:
     • #include “hal_voice_algo_asr_local.h”,
     • #include “hal_event_descriptor_voice.h”
4. För de olika händelsemeddelandena, implementera de nya funktionerna _OutputManagerNotify(), _SetFaceRec(), _RegisterGUIFaceRec() och DeregisterGUIFaceRec() med hänvisning till funktionerna _StopFaceRec(), _RegisterCoffeeSelection() och DeregisterCoffeeSelection() innan du tar bort dem.
   • _OutputManagerNotify() implementerar den grundläggande händelseutgångsfunktionen för att skicka en händelse till visionalgo HAL. Funktionerna nedan kallar det att skicka sina egna händelser.
   • _SetFaceRec() skickar händelsen kEventFaceRecID_OasisSetState för att trigga visionalgon för ansiktsregistrering, igenkänning och stoppa algon.
   • _RegisterGUIFaceRec() skickar händelsen kEventFaceRecId_RegisterGUIFaceRec som är definierad i smart_tlhmi_event_descriptor.h för att lägga till ansiktsfunktionsdata till databasen när registreringen är OK.
   • DeregisterGUIFaceRec() skickar händelsen kEventFaceRecID_DelUser för att radera ansiktsfunktionsdata från databasen när ansiktsigenkänningen passerar.
5. Uppdatera koderna för att vidta motsvarande åtgärder, inklusive uppdatera GUI genom att anropa API:erna från LVGL GUI-appen för slutledningsresultat av ansiktsregistrering och igenkänning i funktionen _InferComplete_Vision() enligt ex.ample's design. Till exempelample, när ansiktsregistreringen lyckas,
   • Sluta visa framstegen genom att anropa _FaceRecProcess_Stop();
   • Stoppa ansiktsregistreringen genom att anropa _SetFaceRec(kOASISLiteState_Stopped);
   • Visa det lyckade resultatet på GUI: gui_show_face_rec_result(kFaceRecResult_OK, s_UserId);
   • Registrera ansiktsdata till databasen: _RegisterUserFace(s_UserId);
6. Lägg till UI-återuppringningsfunktioner för att hantera händelserna: preview, ansiktsregistrering, igenkänning och borttagning av användare som utlösts från GUI. Till exempelample, ansiktsregistreringsåteruppringningen: void UI_Registration_Callback(){ _SetFaceRec(kOASISLiteState_Registration); _FaceRecProcess_Start(); }
   • Och lägg till funktionerna _FaceRecProcess_Start() och _FaceRecProcess_Stop() för att visa framsteg och status i de olika händelserna och resultaten.
   • Uppdatera timer ISR callback-funktionen _SessionTimer_Callback() för att hantera fallet med time-out genom att anropa: gui_show_face_rec_result(kFaceRecResult_TimeOut, s_UserId);
7. Lägg till nedanstående definitioner för att aktivera UI-utgång HAL i board_define.h: #define ENABLE_OUTPUT_DEV_UiGUIFaceRec

Varsel:
För att presentera ansiktsigenkänningsfunktionen bättre, behåll funktionen för att visa processen och resultaten av ansiktsigenkänning i utdata-UI HAL. Funktionen beskrivs nedan

• Ansiktsguiderektangeln visar blått och förloppsindikatorn visar framstegen när ansiktsregistreringen eller -igenkänningen startas.
• Ansiktsguiderektangeln visar rött när ansiktsregistreringen har lyckats.
• Ansiktsguiderektangeln visar grönt när ansiktsigenkänningen lyckas.
• Ansiktsguiderektangeln förblir blå och förloppsindikatorn visar hela framsteg när åtgärden misslyckas efter timerns utgång. Vid den tidpunkten stoppar du ansiktsregistreringen eller igenkänningen.

Förloppsindikatorn och ansiktsguiderektangeln presenteras som de ikoner som är inbyggda i resursbinären file ska programmeras till Flash. Pekarna till ikondata på SDRAM ställs in i funktionen LoadIcons(APP_ICONS_BASE) som anropas på utgångs-UI HAL-enhetens initialisering i utgångs-UI HAL. Det måste implementera ikonstödet för funktionen.

Implementera ikonstödet

1. Bygg resursen genom att kombinera ikonerna med bilderna som används i LVGL GUI-appen:
   • Klona rubriken med fyra ikoner files process_bar_240x14.h, virtual_face_blue_420x426.h, virtual_face_green_420x426.h och virtual_face_red_420x426.h från smart HMI
     \kaffemaskin\resurs\ikoner\ till de nya mappikonerna under resursmappen för example SW.
   • Lägg till sökvägen för de fyra ikonerna files i camera_preview_resource.txt file i resursmappen, till exempelample: icon ../resource/icons/process_bar_240x14.h
   • Kör camera_preview_resource_build.bat för att bygga bilder och ikonresurser för att generera papperskorgen file camera_preview_resource.bin och informationen file resource_information_table.txt (se figur 6).
2. Definiera startadressen på SDRAM och storleken på ikonerna i app_config.h. Adressen börjar bredvid bilderna av GUI-appen. Storleken genereras i infon file. #define APP_ICONS_BASE (APP_RES_SHMEM_BASE + APP_LVGL_IMGS_SIZE) #define APP_ICONS_SIZE 0x107c40
3. Uppdatera den tilldelade storleken på minnessektionen som heter res_sh_mem till 0x200000 genom att omdefiniera den i app_config.h: #define RES_SHMEM_TOTAL_SIZE 0x200000 och motsvarande inställning i Projekt > Egenskaper > C/C++ Bygg > MCU-inställningar.
4. Lägg till ikonstorleken till den totala storleken på resursen som laddas från Flash till SDRAM i funktionen APP_LoadResource() i huvudsak file lvgl_gui_face_rec_cm7.cpp: memcpy((void *)APP_LVGL_IMGS_BASE, pLvglImages, APP_LVGL_IMGS_SIZE + APP_ICONS_SIZE);

Varsel: För att slutföra ansiktsigenkänningsfunktionen behövs stöd för LVGL GUI-appen. UI-återuppringningsfunktionerna i utdata-UI HAL anropas av LVGL GUI-appen för att hantera händelserna från UI-skärmen. Å andra sidan anropar utgångsgränssnittet HAL API:erna från LVGL GUI-appen för att uppdatera användargränssnittet för att visa resultatet och statusen. Utvecklingen av LVGL GUI-appen är relativt oberoende och introducerad i avsnitt 4.3.

4.1.5 Starta HAL-enheter och hanterare för ansiktsigenkänning
Den aktiverade vision algo HAL och UI output HAL och deras chefer startas i huvudsak file
lvgl_gui_face_rec_cm7.cpp efter omvandlingarna av utvecklingen på ramverket enligt nedan:

1. Inkludera rubriken file relaterade till de två HAL-cheferna genom att lägga till kodraden:
   • #include ” fwk_output_manager.h ”
   • #inkludera "fwk_vision_algo_manager.h"
2. Deklarera HAL-enheterna:
   • HAL_VALGO_DEV_DECLARE(OasisGUIFaceRec);
   • HAL_OUTPUT_DEV_DECLARE(UiGUIFaceRec);
3. Registrera HAL-enheterna:
   • HAL_VALGO_DEV_REGISTER(OasisGUIFaceRec, ret);
   • HAL_OUTPUT_DEV_REGISTER(UiGUIFaceRec, ret);
4. Initiera cheferna:
   • FWK_MANAGER_INIT(VisionAlgoManager, ret);
   • FWK_MANAGER_INIT(OutputManager, ret);
5. Starta cheferna:
   • FWK_MANAGER_START(VisionAlgoManager, VISION_ALGO_MANAGER_TASK_PRIORITY, ret);
   • FWK_MANAGER_START(OutputManager, OUTPUT_MANAGER_TASK_PRIORITY, ret);
6. Definiera prioritet för chefsuppgifterna:
   • #define VISION_ALGO_MANAGER_TASK_PRIORITY 3
   • #define OUTPUT_MANAGER_TASK_PRIORITY 1

Lägg till stöd för ansiktsdatabas på ramverket
Den registrerade ansiktsfunktionsdata nås i ansiktsdatabasen lagrad på Flash via lite file systemet. Stegen för att lägga till stöd för ansiktsdatabasen beskrivs nedan.

Lägg till drivrutiner för Flash-lagring
Kopiera Flash-gränssnittets FlexSPI-drivrutin files fsl_flexspi.c och fsl_flexspi.h, och datakrypteringsdrivrutinen files fsl_caam.c och fsl_caam.h från sökvägen SDK_2_13_0_MIMXRT1170-EVK\devices \MIMRX1176\drivers\ till mappen drivrutiner i exetample SW.

Lägg till stöd på styrelsenivå

1. Lägg till definitionerna av FlexSPI som används för Flash-enheten ombord i board.h:
   • #define BOARD_FLEXSPI FLEXSPI1
   • #define BOARD_FLEXSPI_CLOCK kCLOCK_FlexSpi1
   • #define BOARD_FLEXSPI_AMBA_BASE FlexSPI1_AMBA_BASE
2. Kopiera operatörerna och konfigurationerna files av Flash-enheten flexspi_nor_flash_ops.c, flexspi_nor_flash_ops.h, sln_flash_config.c, sln_flash_config_w25q256jvs.h, ochsln_flash_ops.h under sökvägen smart HMI_7\coffee_source_fcm till mappen ex.ample SW.
   • Avmarkera "Uteslut resurs från konstruktion" i C/C++ Build > Inställningar efter att ha högerklickat på files namn och öppna egenskaperna för att de ska kunna byggas in i projektet.
3. Ändra den medföljande rubriken filenamn sln_flash_config.h till sln_flash_config_w25q256jvs.h i sln_flash_config.c och flexspi_nor_flash_ops.h.
4. Ställ in klockkällan för FlexSPI1 i file clock_config.c som hänvisar till kaffemaskinsappen.

Lägg till adapter och mellannivåstöd

1. Kopiera files sln_flash.c, sln_flash.h, sln_encrypt.c och sln_encrypt.h som adapterdrivrutiner för file system och app från sökvägen till smart HMI\coffee_machine\cm7\source\ till mappkällan för exetample. Uppdatera den nya files:
   • Avmarkera "Uteslut resurs från bygg" på dem för att bygga.
   • Ändra alla inkluderade rubriker file namn sln_flash_config.h till sln_flash_config_w25q256jvs.h.
2. Kopiera mappen filesystem som innehåller API:er för de små filesystem och HAL-drivrutin från smart HMI \coffee_machine\cm7\source\ till example SW. Och uppdatera för den nya mappen:
   • Avmarkera "Uteslut resurs från bygg" på den för att bygga.
   • Lägg till sökvägen för den i projektinställningarna: "${workspace_loc:/${ProjName}/filesystemet}"
   • Ändra den medföljande rubriken file namn sln_flash_config.h till sln_flash_config_w25q256jvs.h och fica_definition.h till app_config.h i file sln_flash_littlefs.h.
3. Kopiera mappen littlefs som innehåller mellanvaran – little filesystem från sökvägen SDK_2_13_0_ MIMXRT1170-EVK\middleware\ till example SW. Och uppdatera den nya mappen:
   • Avmarkera "Uteslut resurs från bygg" på den för att bygga.
   • Lägg till inkluderingssökvägen för den i projektinställningarna: "${workspace_loc:/${ProjName}/littlefs}"

Lägg till HAL-drivrutiner 

• Det finns två HAL-enheter – file system- och ansiktsdatabas HAL stöds för databasåtkomstfunktionen och de är redan implementerade i ramverket utan någon förändring. Aktivera dem genom att lägga till nedanstående definitioner i board_define.h:
  • #define ENABLE_FLASH_DEV_Littlefs
  • #define ENABLE_FACEDB

Och ändra namnet på ansiktsdatabasen för exetample: #define OASIS_FACE_DB_DIR “oasis_gui_face_rec”

Lägg till stöd på appnivå

1. Uppdatera huvudet file lvgl_gui_face_rec_cm7.cpp:
   • Inkludera rubriken file relaterat till Flash file system HAL manager genom att lägga till kodraden: #include “fwk_flash.h”
   • Deklarera och registrera file system HAL-enhet:
     • HAL_FLASH_DEV_DECLARE(Littlefs);
     • HAL_FLASH_DEV_REGISTER(Littlefs, ret);
       Notera: Den file system HAL-enhet måste registreras innan alla enhetshanterare initieras i funktionen APP_InitFramework().
   • Anropa funktionen BOARD_ConfigMPU() i APP_BoardInit() för att konfigurera MPU.
2. Ställ in file systemtilldelning på Flash i file app_config.h genom att definiera makrodefinitionerna som används i file sln_flash_littlefs.h:
   • #define FICA_IMG_FILE_SYS_ADDR (FLASH_IMG_SIZE + RES_SHMEM_TOTAL_SIZE)
   • #define FICA_FILE_SYS_SIZE (0x280000)

Konfigurationer
Vissa Flash-relaterade koder exekveras i SRAM ITC-området för tillräcklig prestanda. Kopiera mappen länkskript som innehåller länkkonfigurationerna från sökvägen smart HMI\coffee_machine\cm7\ till exetample SW.

Implementera en LVGL GUI-app
Utvecklingen av en LVGL GUI-app baserad på ramverk anropar API:erna från output UI HAL och tillhandahåller API:erna för att mata ut UI HAL (se avsnitt 4.1.3 för implementering av output UI HAL).

Den detaljerade implementeringen av en LVGL GUI-app beror dock på applikationens krav och design. GUI-appen i detta example är utformad enligt beskrivningen i början av avsnitt 4.

Nedan följer implementeringsintroduktionerna:

1. De anpassade koderna implementeras i custom.c och custom.h som ges av GUI Guider som gränssnittet mellan GUI Guider-projektet och det inbäddade systemprojektet.
   •  Lägg till de nya funktionerna som heter gui_xxx() i custom.c för att uppnå följande funktioner:
     • För utdata UI HAL och GUI app för att uppdatera UI.
     • För att GUI-appen ska utlösa händelser genom att anropa UI-återuppringningsfunktioner från utgångs-UI HAL.
       Till exempelample, den nya funktionen gui_event_face_rec_action() anropar UI-återuppringningsfunktioner för att hantera en av händelserna med ansiktsregistrering, ansiktsigenkänning och borttagning av användare som utlöses från GUI-appen när den relaterade knappen klickas.
       Obs: Funktionen gui_set_virtual_face() anropade i output UI HAL för preview läge måste implementeras i custom.c:
   •  Klona funktion gui_set_virtual_face() från smart HMI\coffee_machine\cm4\custom \custom.c.
   •  Ändra widgetens namn home_img_cameraPreview till screen_img_camera_preview i funktionen.
   •  Implementera UI-återuppringningsfunktionerna med samma prototyp till alla i output UI HAL under kontroll av makrodefinitionen #ifndef RT_PLATFORM i custom.c för att vara kompatibla med GUI Guider-projektet eftersom dessa funktioner i output UI HAL är beroende av inbäddad plattform. I custom.c är de beroende av simulatorn på GUI-guiden och är oberoende av den inbäddade plattformen. Till exempelample, ansiktsregistreringsanropet implementeras enligt nedan för GUI Guider-simulatorn som körs: #ifndef RT_PLATFORM void UI_Registration_Callback() { gui_hide_del_user_btn(true); s_InAction = falskt; lämna tillbaka; }
     Notera: Se samma prototyp av funktionen som introducerades i steg 6 i avsnitt 4.1.3
     Makrodefinitionen RT_PLATFORM är inställd på projektinställningarna för MCUXpresso som visas i figur 7:
   • Deklarera alla funktioner som heter UI_xxx_Callback() och gui_xxx() i custom.h och lägg till custom.h som ingår i smart_tlhmi_event_descriptor.h för att dela GUI API:erna till UI-utgången HAL.
2. Utveckla GUI på GUI Guider:
   • Klona mappen kamera preview som innehåller GUI Guider-projektmjukvaran i mappen gui_guider i basprogrampaketet lvgl_gui_camera_preview_cm7. Ändra det relaterade namnet camera_preview till face_rec för det nya exetample.
   • Kopiera ovanstående uppdaterade custom.c och custom. h till den nya GUI Guider-projektmjukvaran.
   •  Öppna det nya face_rec-projektet på GUI Guider. Uppdatera enligt nedan:
     • Lägg till den nya knappen märkt Ta bort användare. Lägg till flaggan Hidden till den så att knappen döljs när GUI-appen startar.
     • Lägg till kodraden för att anropa API gui_event_face_rec_action() med annan händelse-ID-parameter på "Released"-utlösaren i händelseinställningen för alla knapparna Registrering, Erkännande och Ta bort användare för att utlösa händelserna med ansiktsregistrering, ansiktsigenkänning och borttagning av användare. Figur 8 visar koden för händelsen med knappen Registrering:
3. Uppdatera den genererade koden från GUI Guider till MCUXpresso-projektet.
   • Ersätt innehållet förutom mappbilderna i mappen som genereras av MCUXpresso-projektet SW med motsvarande i mappen som genereras av GUI Guider-projektet SW.

Notera: För mer information om ändringarna som introducerades ovan, kolla exampprogramvaran på https://mcuxpresso.nxp.com/appcodehub.

Verifikationer med example projektet

För att få exetampmjukvarupaketet som innehåller resurserna och verktygen för denna applikationsanteckning, besök: https://mcuxpresso.nxp.com/appcodehub. Öppna exetampett projekt på MCUXpresso IDE. Bygg och programmera .axf file till adressen 0x30000000 och programmera resursfacket file camera_preview_resource.bin till adressen 0x30800000.

LVGL GUI ansiktsigenkänning example fungerar normalt enligt nedan:

• Preview: När strömmen slås på visas videoströmmarna som tagits av kameran på det specifika området av kameran föreview på GUI-skärmen. Statusetiketten visar "Preview…”. För detaljer, se figur 3. Knappen Ta bort användare är dold. När du klickar på området utanför knapparna och bilderna visar det preview ange som ovan efter att ansiktsregistreringen eller igenkänningsåtgärden avslutas.
• Registrering:
  • tartup: När du klickar på knappen Registrering startar ansiktsregistreringen. Statusetiketten ändras till att visa "Registrering...", ansiktsguiderektangeln visar blått och förloppsindikatorn börjar visa förloppet. Se till att användarens ansikte syns i den blå ansiktsguiderektangeln för registrering.
  • framgång: Statusetiketten visar "Registration...OK" och det registrerade användar-ID-numret, ansiktsguiderektangeln blir röd om ansiktsregistreringen lyckades innan förloppet visas fullt i fältet.
  • Misslyckande -> Timeout: Statusetiketten visar "Registration...Time out" om ansiktsregistreringen fortfarande misslyckades när förloppet visas fullt i fältet.
  • Misslyckande -> Duplicering: Statusetiketten visar "Registrering ... Misslyckades", ansiktsguiderektangeln blir grön om det registrerade ansiktet känns igen innan förloppet visas fullt i fältet.
• ekognition:
  • Start: När du klickar på knappen Igenkänning startar ansiktsigenkänningen. Statusetiketten ändras till att visa "Igenkänning...", ansiktsguiderektangeln visar blått och förloppsindikatorn börjar visa förloppet. Se till att användarens ansikte visas i den blå ansiktsguiderektangeln för registrering.
  • framgång: Statusetiketten visar "Recognition...OK" och det igenkända användar-ID-numret, ansiktsguiderektangeln blir grön om ansiktsigenkänningen lyckas innan förloppet visas fullt i fältet. Vid den punkten visas knappen Ta bort användare. Det betyder att användaren endast tillåts tas bort när den känns igen.
  • sjukdom: Statusetiketten visar "Recognition...Time out" om ansiktsigenkänningen fortfarande misslyckas när förloppet visas fullt i fältet.
• Ta bort användare: När knappen "Ta bort användare" klickas, efter att ansiktsigenkänningen lyckats, ändras statusetiketten till att visa "Ta bort användare...OK" med ansiktsguiderektangeln blir blå och förloppet visas fullt i fältet. Knappen Ta bort användare är dold igen. Det igenkända ansiktet/användaren raderas från databasen. Det betyder att detta ansikte/användare inte kan kännas igen förrän den är registrerad igen.

Notera om källkoden i dokumentet
ExampKoden som visas i detta dokument har följande copyright- och BSD-3-klausullicens:

Copyright 2024 NXP Omdistribution och användning i källform och binär form, med eller utan modifiering, är tillåten förutsatt att följande villkor är uppfyllda:

1. Vidaredistribution av källkod måste innehålla ovanstående copyrightmeddelande, denna lista med villkor och följande ansvarsfriskrivning.
2. Vidaredistributioner i binär form måste återge ovanstående copyrightmeddelande, denna lista med villkor och följande friskrivningsklausul i dokumentationen och/eller annat material måste tillhandahållas med distributionen.
3. Varken namnet på upphovsrättsinnehavaren eller namnen på dess bidragsgivare får användas för att rekommendera eller marknadsföra produkter som härrör från denna programvara utan särskilt skriftligt tillstånd i förväg

DENNA PROGRAM TILLHANDAHÅLLS AV UPPHOVSRÄTTSINNEHAVARERNA OCH BIDRAGARE "I BEFINTLIGT SKICK" OCH EVENTUELLA UTTRYCKTA ELLER UNDERFÖRSTÅDDA GARANTIER, INKLUSIVE, MEN INTE BEGRÄNSADE TILL, UNDERFÖRSTÅDDA GARANTIER FÖR SÄLJBARHET OCH LÄMPLIGHET FÖR EN DISPLICITET. UNDER INGA OMSTÄNDIGHETER SKA UPPHAVSRÄTTSINNEHAVAREN ELLER BIDRAGSGIVARNA VARA ANSVARIGA FÖR NÅGON DIREKT, INDIREKTA, OAVSIKTLIGA, SPECIELLA, EXEMPELSKADOR ELLER FÖLJDSKADOR (INKLUSIVE, MEN INTE BEGRÄNSADE TILL, UPPHANDLING AV ERSÄTTNINGSTJÄNSTVAROR, D; ELLER VINST; ELLER AFFÄRSAVBROTT) OAVSETT ORSAKADE OCH PÅ NÅGON ANSVARSTEORI, OAVSETT I KONTRAKT, STIKT ANSVAR ELLER SKADESTÅND (INKLUSIVE FÖRSIKTIGHET ELLER ANNAT SÄTT) SOM UPPSTÅR PÅ NÅGOT SÄTT FRÅN ANVÄNDNINGEN. MÖJLIGHET FÖR SÅDAN SKADA.

Revisionshistorik

Juridisk information

Definitioner
Utkast — En utkaststatus på ett dokument indikerar att innehållet fortfarande är interntview och är föremål för formellt godkännande, vilket kan leda till ändringar eller tillägg. NXP Semiconductors ger inga utfästelser eller garantier för riktigheten eller fullständigheten av information som ingår i ett utkast av ett dokument och ska inte ha något ansvar för konsekvenserna av användningen av sådan information.

Ansvarsfriskrivning

• Begränsad garanti och ansvar — Informationen i detta dokument anses vara korrekt och tillförlitlig. NXP Semiconductors ger dock inga utfästelser eller garantier, uttryckta eller underförstådda, beträffande riktigheten eller fullständigheten av sådan information och ska inte ha något ansvar för konsekvenserna av användningen av sådan information. NXP Semiconductors tar inget ansvar för innehållet i detta dokument om det tillhandahålls av en informationskälla utanför NXP Semiconductors.
  Under inga omständigheter ska NXP Semiconductors hållas ansvarigt för några indirekta, tillfälliga, bestraffande, speciella eller följdskador (inklusive – utan begränsning – förlorad vinst, förlorade besparingar, affärsavbrott, kostnader relaterade till borttagning eller utbyte av produkter eller omarbetningsavgifter) oavsett om eller inte är sådana skador baserade på skadestånd (inklusive vårdslöshet), garanti, avtalsbrott eller någon annan juridisk teori.
  Oavsett eventuella skador som kunden kan ådra sig av någon anledning, ska NXP Semiconductors samlade och kumulativa ansvar gentemot kunden för de produkter som beskrivs här begränsas i enlighet med villkoren för kommersiell försäljning av NXP Semiconductors.
• Rätt att göra ändringar — NXP Semiconductors förbehåller sig rätten att göra ändringar i information som publiceras i detta dokument, inklusive utan begränsning specifikationer och produktbeskrivningar, när som helst och utan föregående meddelande. Detta dokument ersätter och ersätter all information som tillhandahållits före publiceringen av detta.
• Lämplighet för användning — NXP Semiconductors-produkter är inte utformade, auktoriserade eller garanterade för att vara lämpliga för användning i livsuppehållande, livskritiska eller säkerhetskritiska system eller utrustning, och inte heller i applikationer där fel eller fel på en NXP Semiconductors-produkt rimligen kan förväntas leda till personskada, dödsfall eller allvarlig egendoms- eller miljöskada. NXP Semiconductors och dess leverantörer tar inget ansvar för inkludering och/eller användning av NXP Semiconductors produkter i sådan utrustning eller applikationer och därför sker sådan inkludering och/eller användning på kundens egen risk.
• Ansökningar — Tillämpningar som beskrivs här för någon av dessa produkter är endast för illustrativa syften. NXP Semiconductors ger inga utfästelser eller garantier för att sådana applikationer kommer att vara lämpliga för den specificerade användningen utan ytterligare testning eller modifiering.
  Kunder är ansvariga för design och drift av sina applikationer och produkter som använder NXP Semiconductors-produkter, och NXP Semiconductors tar inget ansvar för någon hjälp med applikationer eller kundproduktdesign. Det är kundens ensamma ansvar att avgöra om NXP Semiconductors-produkten är lämplig och passande för kundens applikationer och planerade produkter, såväl som för den planerade applikationen och användningen av kundens tredje parts kund(er). Kunder bör tillhandahålla lämpliga design- och driftssäkerhetsåtgärder för att minimera riskerna förknippade med deras applikationer och produkter. NXP Semiconductors accepterar inget ansvar relaterat till fel, skador, kostnader eller problem som är baserade på någon svaghet eller fel i kundens applikationer eller produkter, eller applikationen eller användningen av kundens tredje parts kund(er). Kunden ansvarar för att göra alla nödvändiga tester för kundens applikationer och produkter med hjälp av NXP Semiconductors-produkter för att undvika fel på applikationerna och produkterna eller applikationen eller användning av kundens tredje parts kund(er). NXP tar inget ansvar i detta avseende.
• Villkor för kommersiell försäljning — NXP Semiconductors-produkter säljs enligt de allmänna villkoren för kommersiell försäljning, som publiceras på https://www.nxp.com/profile/villkor, om inte annat avtalats i ett giltigt skriftligt individuellt avtal. Om ett individuellt avtal ingås gäller endast villkoren i respektive avtal. NXP Semiconductors invänder härmed uttryckligen mot att tillämpa kundens allmänna villkor med avseende på köp av NXP Semiconductors produkter av kunden.
• Exportkontroll — Detta dokument såväl som de föremål som beskrivs häri kan vara föremål för exportkontrollbestämmelser. Export kan kräva ett förhandstillstånd från behöriga myndigheter.
• Lämplighet för användning i icke-bilkvalificerade produkter — Om inte detta dokument uttryckligen anger att denna specifika NXP Semiconductors-produkt är bilkvalificerad, är produkten inte lämplig för bilbruk. Den är varken kvalificerad eller testad i enlighet med fordonstestning eller applikationskrav. NXP Semiconductors tar inget ansvar för inkludering och/eller användning av icke-bilkvalificerade produkter i fordonsutrustning eller applikationer.
  I händelse av att kunden använder produkten för design-in och användning i fordonstillämpningar enligt fordonsspecifikationer och standarder, ska kunden (a) använda produkten utan NXP Semiconductors garanti för produkten för sådana fordonstillämpningar, användning och specifikationer, och ( b) närhelst kunden använder produkten för fordonstillämpningar utöver NXP Semiconductors specifikationer ska sådan användning enbart ske på kundens egen risk, och (c) kunden håller NXP Semiconductors helt skadeslös för eventuellt ansvar, skador eller misslyckade produktanspråk som härrör från kundens design och användning av produkten för fordonstillämpningar utöver NXP Semiconductors standardgaranti och NXP Semiconductors produktspecifikationer.
• Översättningar — En icke-engelsk (översatt) version av ett dokument, inklusive den juridiska informationen i det dokumentet, är endast för referens. Den engelska versionen ska ha företräde vid eventuella avvikelser mellan de översatta och engelska versionerna.
• Säkerhet — Kunden förstår att alla NXP-produkter kan vara föremål för oidentifierade sårbarheter eller kan stödja etablerade säkerhetsstandarder eller specifikationer med kända begränsningar. Kunden ansvarar för utformningen och driften av sina applikationer och produkter under hela deras livscykel för att minska effekten av dessa sårbarheter på kundens applikationer och produkter. Kundens ansvar sträcker sig även till andra öppna och/eller patentskyddade teknologier som stöds av NXP-produkter för användning i kundens applikationer. NXP tar inget ansvar för någon sårbarhet. Kunden bör regelbundet kontrollera säkerhetsuppdateringar från NXP och följa upp på lämpligt sätt. Kunden ska välja produkter med säkerhetsfunktioner som bäst uppfyller regler, föreskrifter och standarder för den avsedda applikationen och fatta de slutgiltiga designbesluten angående sina produkter och är ensamt ansvarig för att alla lagar, regler och säkerhetsrelaterade krav som gäller sina produkter, oavsett av all information eller support som kan tillhandahållas av NXP.

NXP har ett Product Security Incident Response Team (PSIRT) (tillgängligt på PSIRT@nxp.com) som hanterar utredning, rapportering och lösningssläpp för säkerhetsbrister i NXP-produkter.
NXP BV — NXP BV är inte ett operativt företag och det distribuerar eller säljer inte produkter.

Varumärken
Varsel: Alla refererade varumärken, produktnamn, tjänstenamn och varumärken tillhör sina respektive ägare.

NXP — ordmärke och logotyp är varumärken som tillhör NXP BV

AMBA, Arm, Arm7, Arm7TDMI, Arm9, Arm11, Artisan, big.LITTLE, Cordio, CoreLink, CoreSight, Cortex, DesignStart, DynamIQ, Jazelle, Keil, Mali, Mbed, Mbed Enabled, NEON, POP, RealView, SecurCore, Socrates, Thumb, TrustZone, ULINK, ULINK2, ULINK-ME, ULINK-PLUS, ULINKpro, μVision, Versatile — är varumärken och/eller registrerade varumärken som tillhör Arm Limited (eller dess dotterbolag eller dotterbolag) i USA och/eller någon annanstans. Den relaterade teknologin kan skyddas av något eller alla patent, upphovsrätter, mönster och affärshemligheter. Alla rättigheter förbehållna.

• i.MX — är ett varumärke som tillhör NXP BV
• J-Link — är ett varumärke som tillhör SEGGER Microcontroller GmbH.

Microsoft, Azure och ThreadX — är varumärken som tillhör Microsoft-företagsgruppen.

Var medveten om att viktiga meddelanden om detta dokument och de produkter som beskrivs här har inkluderats i avsnittet "Juridisk information".

© 2024 NXP BV
För mer information, besök: https://www.nxp.com

• Releasedatum: 19 april 2024
• Dokumentidentifierare: AN14263

FAQ

F: Vad är huvudsyftet med denna produkt?
S: Huvudsyftet är att aktivera ansiktsigenkänningsfunktionen med hjälp av en AI&ML-visionalgoritmmodell med ett enkelt LVGL GUI ex.ample på SLN-TLHMI-IOT-kortet.

F: Hur kan utvecklare dra nytta av den här applikationsanteckningen?
S: Utvecklare kan lära sig hur man implementerar ansiktsigenkänning på ramverket steg för steg med hjälp av exampläsa och förstå enhetshanterare, HAL-enheter och händelsemekanismer som är involverade.

Dokument/resurser

NXP AN14263 Implementera LVGL GUI Ansiktsigenkänning på Framewor [pdf] Användarhandbok AN14263 Implementera LVGL GUI Ansiktsigenkänning på Framewor, AN14263, Implementera LVGL GUI Ansiktsigenkänning på Framewor, LVGL GUI Ansiktsigenkänning på Framewor, Ansiktsigenkänning på Framewor, Recognition på Framewor, Framewor

Referenser

• Användarmanual