NXP AN14263 Implémenter la reconnaissance faciale de l'interface graphique LVGL sur Framewor

Informations sur le produit

Caractéristiques

• Nom du produit: Reconnaissance faciale LVGL GUI sur Framework
• Révision du document : 1 – 19 avril 2024
• Mots clés: Reconnaissance faciale, interface graphique LVGL, framework

Instructions d'utilisation du produit

1. Surview
   Ce produit permet au modèle d'algorithme de vision AI&ML pour la reconnaissance faciale sur un framework d'implémenter la fonction de reconnaissance faciale avec une simple interface graphique LVGL ex.ample sur la carte SLN-TLHMI-IOT.
2. Cadre terminéview
   La solution logicielle est conçue autour d'une architecture-cadre qui comprend des gestionnaires de périphériques chargés de gérer les périphériques, des périphériques HAL pour extraire les détails sous-jacents et des événements pour la communication entre différents périphériques.
3. Caractéristiques
   Le produit permet la mise en œuvre de la fonction de reconnaissance faciale via un pré-appareil photo.view sur l'écran GUI avec des boutons pour déclencher l'enregistrement, la reconnaissance et la suppression du visage. Les données de visage enregistrées sont stockées sur Flash via un file système.
4. Contenu de la note d'application
   La note d'application présente un écran GUI LVGL avec pré-caméraview et des boutons pour les actions liées au visage. Il aide les développeurs à comprendre le cadre et comment implémenter la reconnaissance faciale à l'aide de l'ex fourni.ample.

Surview

NXP a lancé un kit de développement de solutions nommé SLN-TLHMI-IOT qui se concentre sur les applications IHM intelligentes. Il permet une IHM intelligente avec une interface utilisateur de vision, vocale et graphique ML implémentée sur un MCU NXP i.MX RT117H. Basé sur le SDK, le logiciel de solution est construit sur une conception appelée framework qui prend en charge des conceptions flexibles et la personnalisation des fonctions de vision et de voix. Pour aider les utilisateurs à mieux utiliser la plateforme logicielle, quelques documents de base sont fournis, par example, le guide de l'utilisateur du développement logiciel. Le guide présente la conception logicielle de base et l'architecture des applications couvrant tous les composants de la solution, y compris le cadre pour aider les développeurs à mettre en œuvre plus facilement et plus efficacement leurs applications à l'aide du SLN-TLHMI-IOT.
Pour plus de détails sur la solution et les documents pertinents, visitez le web page de la solution NXP EdgeReady Smart HMI basée sur i.MX RT117H avec ML Vision, voix et interface utilisateur graphique. Cependant, il n'est toujours pas si simple pour les développeurs de mettre en œuvre leurs applications IHM intelligentes en se référant à ces guides de base. Une série de notes d’application sont prévues pour aider à étudier étape par étape le développement du framework. Cette note d'application est basée sur Implement LVGL GUI Camera Preview sur le Cadre (document AN14147). Cette note d'application décrit comment activer le modèle d'algorithme de vision AI&ML pour la reconnaissance faciale sur le framework afin d'implémenter la fonction de reconnaissance faciale via le pré-caméra.view sur l'écran GUI avec un simple ex GUI LVGLample sur la carte SLN-TLHMI-IOT. Dans la note de candidature, l'example présente un écran GUI LVGL avec un pré-appareil photoview et quelques boutons pour déclencher l'enregistrement, la reconnaissance et la suppression du visage. Les données du visage enregistrées sont stockées sur Flash via un petit file système.

À un niveau élevé, la note d'application contient le contenu ci-dessous :

• Activez la fonction de reconnaissance faciale sur le framework.
• Ajouter la prise en charge de la base de données de visages sur le framework via file système sur Flash.
• Implémentez l'application GUI LVGL. A travers les introductions ci-dessus, ce document aide les développeurs à :
• Comprenez plus en profondeur le cadre et le logiciel de la solution Smart HMI.
• Développez leur reconnaissance faciale AI&ML sur un framework avec l'application LVGL GUI.

Cadre terminéview
La solution logicielle est principalement conçue autour de l'utilisation de l'architecture framework qui est composée de plusieurs parties différentes :

• Gestionnaires de périphériques – la partie essentielle
• Périphériques de couche d'abstraction matérielle (HAL)
• Messages/Événements

Comme le montre la figure 1, le plusview du mécanisme du cadre est :

Les gestionnaires de périphériques sont responsables de la gestion des périphériques utilisés par le système. Chaque type de périphérique (entrée, sortie, etc.) possède son propre gestionnaire de périphériques spécifique au type. Avec un gestionnaire de périphériques démarrant après l'enregistrement des appareils, il attend et vérifie un message pour transférer des données vers les appareils et d'autres gestionnaires après l'initialisation et le démarrage des appareils enregistrés. Les périphériques HAL sont écrits au-dessus du code du pilote de niveau inférieur, ce qui contribue à accroître la compréhensibilité du code en faisant abstraction de nombreux détails sous-jacents.

Les événements sont un moyen par lequel des informations sont communiquées entre différents appareils via leurs gestionnaires. Lorsqu'un événement est déclenché, l'appareil qui a reçu l'événement en premier communique cet événement à son gestionnaire, puis il en informe à son tour les autres gestionnaires désignés pour recevoir l'événement.

La conception architecturale du cadre était centrée sur trois objectifs principaux :

1. Facilité d'utilisation
2. Flexibilité/Portabilité
3. Performance

Le cadre est conçu dans le but d’accélérer la mise sur le marché des applications de vision et d’autres applications d’apprentissage automatique. Pour garantir une mise sur le marché rapide, il est essentiel que le logiciel lui-même soit facile à comprendre et à modifier. En gardant cet objectif à l’esprit, l’architecture du framework est facile à modifier sans être restrictive, et sans se faire au détriment des performances.
Pour plus de détails sur le framework, consultez le Guide de l'utilisateur de développement de logiciels Smart HMI (document MCU-SMHMI-SDUG).

Bibliothèque graphique légère et polyvalente (LVGL)
LVGL (Light and Versatile Graphics Library) est une bibliothèque graphique gratuite et open source fournissant tout ce dont vous avez besoin pour créer une interface graphique intégrée avec des éléments graphiques faciles à utiliser, de superbes effets visuels et une faible empreinte mémoire.

Guide de l'interface graphique
GUI Guider est un outil de développement d'interface utilisateur graphique convivial de NXP qui permet le développement rapide d'écrans de haute qualité avec la bibliothèque graphique open source LVGL. L'éditeur glisser-déposer de GUI Guider facilite l'utilisation de nombreuses fonctionnalités de LVGL telles que les widgets, les animations et les styles pour créer une interface graphique avec un minimum de codage, voire aucun.

D'un simple clic, vous pouvez exécuter votre application dans un environnement simulé ou l'exporter vers un projet cible. Le code généré à partir de GUI Guider peut facilement être ajouté à votre projet, accélérant le processus de développement et vous permettant d'ajouter de manière transparente une interface utilisateur intégrée à votre application. GUI Guider peut être utilisé gratuitement avec les MCU à usage général et croisés de NXP et comprend des modèles de projet intégrés pour plusieurs plates-formes prises en charge. Pour en savoir plus sur le développement LVGL et GUI sur GUI Guider, consultez Bibliothèque graphique légère et polyvalente et GUI Guider.

Environnement de développement

Tout d'abord, préparez et configurez l'environnement matériel et logiciel pour la mise en œuvre de l'ex.ample sur le cadre.

Environnement matériel
L'environnement matériel est configuré pour vérifier l'example:

• Le kit de développement HMI intelligent basé sur NXP i.MX RT117H (le kit SLN_TLHMI_IOT)
• SEGGER J-Link avec un adaptateur Cortex-M 9 broches et V7.84a ou une version plus récente du pilote

Environnement logiciel
L'environnement logiciel est configuré pour développer l'example:

• IDE MCUXpresso V11.7.0
• Guide d'interface graphique V1.6.1-GA
• lvgl_gui_camera_preview_cm7 – example code de la deuxième note d'application comme logiciel de base du développement. Pour plus de détails, voir https://mcuxpresso.nxp.com/appcodehub.
• RT1170 SDK V2.13.0 – comme ressource de code pour le développement.
• Logiciel SLN-TLHMI-IOT V1.1.2 – code source de l'IHM intelligente publié sur le référentiel NXP GitHub en tant que ressource de code pour le développement. Pour plus de détails, voir : GitHub – NXP/mcu-smhmi à la version 1.1.2

Pour plus de détails sur l'acquisition et la configuration de l'environnement logiciel, voir : Premiers pas avec le SLN-TLHMI-IOT.

Architecture de vision sur framework

L'architecture de vision sur le framework est illustrée à la figure 2. L'algorithme de vision HAL (OASIS_HAL) comporte les processus ci-dessous :

• Effectuez l'enregistrement et la reconnaissance du visage via le modèle d'algorithme de vision AI&ML après avoir reçu les événements associés de la sortie UI HAL. Notifiez les résultats d’inférence du modèle d’algorithme à la sortie UI HAL.
• Accéder (ajouter, supprimer…) à la base de données des caractéristiques du visage en fonction du petit file système en appelant les API de FaceDB HAL après avoir reçu les événements associés de la sortie UI HAL.
• Demandez l'image vidéo de la caméra à la caméra HAL lors de l'enregistrement et de la reconnaissance du visage.

Implémenter la reconnaissance faciale sur le framework

L'ex de reconnaissance faciale de l'interface graphique LVGLample (l'example est fourni plus tard) sur le cadre est implémenté sur la base de l'examples codes de l'implémentation LVGL GUI Camera Preview sur le Cadre (document AN14147).

Pour avoir démontré la reconnaissance faciale chez l'example, la fonction de base de l'application GUI (voir l'écran principal de la figure 3) est conçue comme décrit ci-dessous :

• L'application GUI déclenche l'événement d'enregistrement ou de reconnaissance du visage sur la sortie UI HAL lorsque vous cliquez sur le bouton Enregistrement ou Reconnaissance. Et la sortie UI HAL notifie l'événement d'ajout d'un utilisateur à l'algorithme de vision HAL une fois l'enregistrement du visage réussi.
• L'application GUI déclenche l'événement de suppression d'un utilisateur dans la sortie UI HAL en cliquant sur le bouton Supprimer l'utilisateur une fois le visage de l'utilisateur reconnu.
• L'application GUI déclenche l'événement d'arrêt de l'algorithme oasis exécuté vers la sortie UI HAL lorsque vous cliquez sur l'écran en dehors des boutons et des images.

Préparer le progiciel pour la mise en œuvre de l'example.

• Cloner le logiciel de base lvgl_gui_camera_preview_cm7. Changez le nom du projet et le principal filenom à lvgl_gui_face_rec_cm7.
• Le framework doit être mis à jour dans le logiciel car les codes sources du noyau du framework ont ​​commencé à être publics sur GitHub à partir de la version 1.1.2.
• Remplacez le dossier framework par la copie de la V1.1.2 de GitHub à l'exception du files fwk_log.h et fwk_common.h sous inc\ car ils ont été modifiés pour la série de notes d'application. Les opérations sont illustrées dans la figure 4 :
• Supprimez le dossier framework_cm7 sous le groupe libs et supprimez la bibliothèque framework_cm7 et son chemin de recherche configuré dans Projet > Propriétés > C/C++ Build > paramètres > Paramètres de l'outil > MCU C++ Linker > Bibliothèques puisque le code source du noyau est fourni.

Activer la fonction de reconnaissance faciale sur le framework
La fonctionnalité de reconnaissance faciale est construite sur le modèle d'algorithme de vision ML fourni sous forme de bibliothèque statique – une bibliothèque d'exécution Oasis Lite de NXP. La bibliothèque est une petite bibliothèque d'IA très efficace, personnalisée et optimisée. Le modèle comprend la détection des visages, la reconnaissance des visages, la détection des verres et la détection de la vivacité. Il fournit principalement l'API OASISLT_run_extended() pour exécuter le pipeline de reconnaissance faciale tout en mettant à jour les résultats pour l'appelant via des rappels d'événements, et ajouter/mettre à jour/supprimer des visages dans la base de données via les rappels de la base de données de visages après avoir spécifié les informations sur la trame source, les rappels et la mémoire. pool utilisé par la bibliothèque en appelant une autre API OASISLT_init() à l'initialisation. L'appel des API et les fonctions de rappel sont implémentés dans l'algo vision HAL du framework.

Ajouter une bibliothèque de modèles d'algorithmes de vision

1. Copier le dossier oasis contenant la bibliothèque et l'en-tête associé file depuis smart HMI\coffee_machine\cm7\libs\ dans le dossier libs de l'example SW.
2. Ajouter le chemin de recherche de l'en-tête file dans Projet > Propriétés > Construction C/C++ > paramètres > Paramètres de l'outil > Compilateur MCU C > Inclut et compilateur MCU C++ > Comprend : « ${workspace_loc:/${ProjName}/libs/oasis/include} »
3. Ajoutez la bibliothèque et son chemin de recherche sur Projet > Propriétés > Construction C/C++ > paramètres > MCU C+ + Linker > Bibliothèques : liboasis_lite2D_DEFAULT_117f_ae.a « ${workspace_loc:/${ProjName}/libs/oasis} » et la définition de la macro à activez la fonctionnalité sur Projet > Propriétés > Construction C/C++ > paramètres > Paramètres de l'outil > Compilateur MCU C > Préprocesseur et compilateur MCU C++ > Préprocesseur : SMART_TLHMI_2D

Activer l'algorithme de vision HAL
L'algorithme de vision HAL fait fonctionner le modèle d'algorithme de vision et répond aux résultats à la sortie de l'interface utilisateur HAL après en avoir reçu les événements.

Pour l'activer, clonez le pilote HAL similaire existant file où les fonctions ci-dessous sont implémentées :

• Implémentez les rappels des opérations de la base de données de visages et la gestion des événements.
• Faites fonctionner l’algorithme de vision en appelant les API de la bibliothèque oasis.
• Accédez à la base de données des visages utilisateur et à la base de données des applications (ce n'est pas nécessaire dans l'example).
• Recevez des événements et envoyez des résultats vers la sortie UI HAL.

Les grands travaux de mise en œuvre du HAL pour l'example sont:

• Cloner le pilote HAL similaire existant file et modifiez les noms associés.
• Supprimez les codes liés aux opérations de données de l'application.
• Mettre à jour les définitions et les fonctions de gestion des événements à partir de la sortie UI HAL selon l'exampla conception.
• Ajoutez les configurations requises lors de l'initialisation d'Oasis.

Les étapes détaillées sont les suivantes :

1. Clonez hal_vision_algo_oasis_coffeemachine.c. Changer la filenom à hal_vision_algo_oasis_guifacerec.c. Et remplacez toutes les chaînes CoffeeMachine par GUIFaceRec dans le file.
2. Supprimez les codes contenant la chaîne coffeedb (non sensible à la casse) liés à la base de données de l'application, par exempleample, #include hal_sln_coffeedb.h.
3. Modifiez la fonction HAL_VisionAlgoDev_OasisGUIFaceRec_InputNotify() pour gérer les événements de la sortie UI HAL.
   • Remplacez la définition d'événement kEventFaceRecId_RegisterCoffeeSelection par kEventFaceRecId_RegisterUserFace et la chaîne de structure regCoffeeSelection par regGUIFaceRec pour la gestion des événements afin d'ajouter de nouvelles données de caractéristiques de visage à la base de données.
   • Pour montrer le processus standard des actions de reconnaissance faciale dans l'example, modifiez la gestion dans le cas de kEventFaceRecID_OasisSetState avec les définitions des états :
     • kOASISLiteState
     • Inscription kOASISLiteState
     • Reconnaissance kOASISLiteState
     • Arrêté
4. Ajoutez et modifiez les définitions des événements mentionnés à l'étape ci-dessus.
   • Copiez l'en-tête file smart_tlhmi_event_descriptor.h depuis smart HMI\coffee_machine \cm7\source\event_handlers\ dans le dossier source de l'example SW. Mettre à jour le file comme ci-dessous:
   • Remplacez la définition d'événement kEventFaceRecId_RegisterCoffeeSelection par kEventFaceRecId_RegisterUserFace dans le type d'énumération _event_smart_tlhmi_id et la chaîne de structure regCoffeeSelection par regGUIFaceRec dans la structure _event_smart_tlhmi. Alors, changez la structure register_coffee_selection_event_t pour regCoffeeSelection en register_gui_facerec_event_t.
   • Supprimez le contenu else utilisé pour l'application de la machine à café, par exempleample, la ligne de code sur la voix : #include "hal_event_descriptor_voice.h".
   • Ajoutez les types kOASISLiteState_Stopped et kOASISLiteState_Running au type enum oasis_lite_state_t dans hal_vision_algo.h sous framework>hal>vision dans le projet comme ci-dessous :
     typedef enum _oasis_lite_state {
     • kOASISLiteState
     • En cours d'exécution, kOASISLiteState
     • Arrêté, kOASISLiteState
     • Reconnaissance,
     • kOASISLiteState
     • Inscription, kOASISLiteState
     • Désinscription, kOASISLiteState
     • Enregistrement à distance, kOASISLiteState
     • Compter
   • Utilisez la structure oasis_lite_state_t mise à jour ci-dessus pour affiner la structure oasis_state_event_t dans hal_event_descriptor_face_rec.h sous framework>hal>vision dans le projet comme ci-dessous : typedef struct _oasis_state_event_t { oasis_lite_state_t state ; } oasis_state_event_t;
5. Remplacez tous les kEventInfo_Remote par kEventInfo_Local pour envoyer des événements de l'algorithme de vision HAL à d'autres HAL exécutés sur le même cœur, car un seul cœur au lieu d'un double cœur est utilisé dans l'ex.ample.
6. Ajoutez et modifiez les configurations ci-dessous pour l'initialisation d'oasis dans OASISLT_init() :
   • Ajoutez les définitions de macro et les sections de mémoire pour l'image vidéo dans board_define.h : #define OASIS_RGB_FRAME_WIDTH 800
     • #définir OASIS_RGB_FRAME_HEIGHT 600
     • #define OASIS_RGB_FRAME_SRC_FORMAT kPixelFormat_YUV1P444_RGB
     • #définir OASIS_RGB_FRAME_BYTE_PER_PIXEL 3
     • #define AT_FB_SHMEM_SECTION_ALIGN(var, alignbytes) \
     • __attribute__((section(“.bss.$fb_sh_mem,\”aw\”,%nobits @”))) var
     • __attribute__((aligné(alignbytes)))
   • Configurez l'affectation de mémoire dans la section de mémoire ci-dessus fb_sh_mem sur Projet > Propriétés > Construction C/C++ > Paramètres MCU illustrés dans la figure 5 :
   • Déclarez la variable globale g_DTCOPBuf dans lvgl_gui_face_rec_cm7.cpp : AT_NONCACHEABLE_SECTION_ALIGN_DTC (uint8_t g_DTCOPBuf[DTC_OPTIMIZE_BUFFER_SIZE], 4) ;
   • Continuez à ajouter les définitions utilisées dans la variable ci-dessus :
   • Définissez la section ci-dessus dans board_define.h :
     • #define AT_NONCACHEABLE_SECTION_ALIGN_DTC(var, alignbytes) \
     • attribut__((section(“.bss.$SRAM_DTC_cm7,\”aw\”,%nobits @”))) var
     • attribut__((aligné(alignbytes)))
   • Inclure l'en-tête file hal_vision_algo.h contenant la définition de macro DTC_OPTIMIZE_BUFFER_SIZE dans app_config.h incluse dans lvgl_gui_face_rec_cm7.cpp.
7. Définissez la variable s_debugOption sur true pour afficher l'état de progression de la reconnaissance faciale.
8. Ajouter le chemin de recherche de l'en-tête files de la vision HAL sur Projet > Propriétés > Construction C/C++ > paramètres > Paramètres de l'outil > Compilateur MCU C > Comprend et compilateur MCU C++ > Comprend : « ${workspace_loc:/${ProjName}/framework/hal/vision} »
9. Ajoutez la définition ci-dessous pour activer l'algorithme de vision HAL dans board_define.h : #define ENABLE_VISIONALGO_DEV_Oasis_GUIFaceRec

Activer la sortie UI HAL
La sortie UI HAL notifie les événements à l'algo de vision HAL et répond aux résultats d'inférence de l'algo de vision HAL. Avec l'application GUI, les événements sont généralement déclenchés par l'application et les résultats sont affichés sur l'application.

Pour l'activer, clonez le pilote HAL similaire existant file où généralement les fonctions ci-dessous sont implémentées :

• Notifiez les événements pour la reconnaissance faciale et l'accès à la base de données.
• Implémentez les rappels pour l'application GUI pour déclencher les événements.
• Gérez les résultats d’inférence du module d’algorithme de vision.
• Affichez le processus et les résultats de la gestion des événements sur l'interface utilisateur par la barre de progression contrôlée avec les minuteries et le rectangle de guidage du visage.

Les grands travaux de mise en œuvre du HAL pour l'examples fichiers utilisés dans ce document sont :

• Cloner le pilote HAL similaire existant file et modifiez les noms associés.
• Supprimez les codes liés à l'application.
• Mettre à jour les fonctions de notification d'événements et de réponse aux résultats selon l'exampla conception.
• Ajoutez les rappels pour l'application GUI pour déclencher les événements.

Les étapes détaillées sont les suivantes :

1. Clonez hal_output_ui_coffee_machine.c. Changer la filenom à hal_output_ui_guifacerec.c.
2. Remplacez toutes les chaînes CoffeeMachine par GUIFaceRec dans le file.
3. Supprimez les codes liés à l’application – machine à café.
   • Supprimez les fonctions WakeUp() et _StandBy() et les codes associés (vous pouvez les rechercher dans la chaîne wake_up et stand-by).
   • Supprimer le préview événements de mode gérant les codes associés dans HAL_OutputDev_UiGUIFaceRec_Input Notify().
   • Supprimez les fonctions UI_xxx_Callback() et les codes contenant la chaîne gui_ et screen liés à l'interface graphique de la machine à café sauf gui_set_virtual_face() pour le préview fonction mode.
   • Supprimez tous les codes impliqués dans les variables s_IsWaitingAnotherSelection et s_IsWaitingRegisterSelection liées à l'application de la machine à café.
   • Supprimez les codes liés à la voix, à l'audio et à la langue. Par exempleample:
     • #include "hal_voice_algo_asr_local.h",
     • #include "hal_event_descriptor_voice.h"
4. Pour la notification des différents événements, implémentez les nouvelles fonctions _OutputManagerNotify(), _SetFaceRec(), _RegisterGUIFaceRec() et DeregisterGUIFaceRec() faisant référence aux fonctions _StopFaceRec(), _RegisterCoffeeSelection() et DeregisterCoffeeSelection() avant de les supprimer.
   • _OutputManagerNotify() implémente la fonction de sortie d'événement de base pour envoyer un événement à l'algo de vision HAL. Les fonctions ci-dessous l'appellent pour envoyer leurs propres événements.
   • _SetFaceRec() envoie l'événement kEventFaceRecID_OasisSetState pour déclencher l'algorithme de vision pour l'enregistrement du visage, la reconnaissance et arrêter l'algorithme.
   • _RegisterGUIFaceRec() envoie l'événement kEventFaceRecId_RegisterGUIFaceRec qui est défini dans smart_tlhmi_event_descriptor.h pour ajouter des données de caractéristiques de visage à la base de données lorsque l'enregistrement est OK.
   • DeregisterGUIFaceRec() envoie l'événement kEventFaceRecID_DelUser pour supprimer les données des caractéristiques du visage de la base de données lors du passage de la reconnaissance faciale.
5. Mettez à jour les codes pour effectuer les actions correspondantes, notamment actualiser l'interface graphique en appelant les API de l'application LVGL GUI pour les résultats d'inférence de l'enregistrement et de la reconnaissance des visages dans la fonction _InferComplete_Vision() selon l'ex.ample design. Par exempleample, lorsque l'enregistrement du visage est réussi,
   • Arrêtez d'afficher la progression en appelant _FaceRecProcess_Stop();
   • Arrêtez l'enregistrement du visage en appelant _SetFaceRec(kOASISLiteState_Stopped);
   • Afficher le résultat réussi sur l'interface graphique : gui_show_face_rec_result(kFaceRecResult_OK, s_UserId);
   • Enregistrez les données du visage dans la base de données : _RegisterUserFace(s_UserId);
6. Ajoutez des fonctions de rappel de l'interface utilisateur pour gérer les événements : preview, l'enregistrement du visage, la reconnaissance et la suppression de l'utilisateur déclenchés à partir de l'interface graphique. Par exempleample, le rappel d'enregistrement du visage : void UI_Registration_Callback(){ _SetFaceRec(kOASISLiteState_Registration); _FaceRecProcess_Start(); }
   • Et ajoutez les fonctions _FaceRecProcess_Start() et _FaceRecProcess_Stop() pour afficher la progression et l'état des différents événements et résultats.
   • Mettez à jour la fonction de rappel ISR du minuteur _SessionTimer_Callback() pour gérer le cas de dépassement de délai en appelant : gui_show_face_rec_result(kFaceRecResult_TimeOut, s_UserId);
7. Ajoutez les définitions ci-dessous pour activer la sortie HAL de l'interface utilisateur dans board_define.h : #define ENABLE_OUTPUT_DEV_UiGUIFaceRec

Avis:
Pour mieux présenter la fonction de reconnaissance faciale, conservez la fonction permettant d'afficher le processus et les résultats de la reconnaissance faciale dans la sortie UI HAL. La fonction est décrite comme ci-dessous

• Le rectangle du guide du visage est bleu et la barre de progression indique la progression lors du démarrage de l'enregistrement ou de la reconnaissance du visage.
• Le rectangle du guide du visage s'affiche en rouge lorsque l'enregistrement du visage est réussi.
• Le rectangle du guide du visage s'affiche en vert lorsque la reconnaissance faciale est réussie.
• Le rectangle du guide du visage reste bleu et la barre de progression affiche la progression complète lorsque l'action échoue après l'expiration du minuteur. À ce stade, arrêtez l’enregistrement ou la reconnaissance du visage.

La barre de progression et le rectangle de guidage du visage sont présentés sous forme d'icônes intégrées au binaire de la ressource. file à programmer en Flash. Les pointeurs vers les données d'icônes sur SDRAM sont configurés dans la fonction LoadIcons(APP_ICONS_BASE) appelée lors de l'initialisation du périphérique UI HAL de sortie dans la sortie UI HAL. Il doit implémenter le support des icônes pour la fonction.

Implémenter le support des icônes

1. Créez la ressource en combinant les icônes avec les images utilisées dans l'application LVGL GUI :
   • Cloner l'en-tête des quatre icônes files process_bar_240x14.h, virtual_face_blue_420x426.h, virtual_face_green_420x426.h et virtual_face_red_420x426.h de l'IHM intelligente
     \machine à café\resource\icons\ vers les nouvelles icônes de dossier sous le dossier de ressources de l'example SW.
   • Ajoutez le chemin de recherche pour l'icône des quatre files dans le camera_preview_resource.txt file dans le dossier des ressources, par exampfichier : icône ../resource/icons/process_bar_240x14.h
   • Exécuter camera_preview_resource_build.bat pour créer les ressources d'images et d'icônes pour générer le bac file camera_preview_resource.bin et les informations file resource_information_table.txt (voir Figure 6).
2. Définissez l'adresse de démarrage sur SDRAM et la taille des icônes dans app_config.h. L'adresse commence à côté des images de l'application GUI. La taille est générée dans l'info file. #définir APP_ICONS_BASE (APP_RES_SHMEM_BASE + APP_LVGL_IMGS_SIZE) #définir APP_ICONS_SIZE 0x107c40
3. Mettez à jour la taille attribuée à la section de mémoire nommée res_sh_mem à 0x200000 en la redéfinissant dans app_config.h : #define RES_SHMEM_TOTAL_SIZE 0x200000 et le paramètre correspondant dans Projet > Propriétés > Construction C/C++ > Paramètres MCU.
4. Ajoutez la taille de l'icône à la taille totale de la ressource chargée de Flash vers SDRAM dans la fonction APP_LoadResource() dans le main file lvgl_gui_face_rec_cm7.cpp : memcpy((void *)APP_LVGL_IMGS_BASE, pLvglImages, APP_LVGL_IMGS_SIZE + APP_ICONS_SIZE);

Avis: Pour compléter la fonction de reconnaissance faciale, la prise en charge de l'application LVGL GUI est nécessaire. Les fonctions de rappel de l'interface utilisateur dans la sortie UI HAL sont appelées par l'application LVGL GUI pour gérer les événements à partir de l'écran de l'interface utilisateur. D'autre part, la sortie UI HAL appelle les API de l'application LVGL GUI pour mettre à jour l'interface utilisateur afin d'afficher le résultat et l'état. Le développement de l'application LVGL GUI est relativement indépendant et introduit dans la section 4.3.

4.1.5 Démarrage des appareils et gestionnaires HAL pour la reconnaissance faciale
L'algo de vision activé HAL et la sortie de l'interface utilisateur HAL et leurs gestionnaires sont démarrés dans l'ensemble file
lvgl_gui_face_rec_cm7.cpp suivant les conversions de développement sur le framework comme ci-dessous :

1. Inclure l'en-tête file lié aux deux gestionnaires HAL en ajoutant la ligne de code :
   • #include « fwk_output_manager.h »
   • #include « fwk_vision_algo_manager.h »
2. Déclarez les appareils HAL :
   • HAL_VALGO_DEV_DECLARE(OasisGUIFaceRec);
   • HAL_OUTPUT_DEV_DECLARE(UiGUIFaceRec);
3. Enregistrez les appareils HAL :
   • HAL_VALGO_DEV_REGISTER(OasisGUIFaceRec, ret);
   • HAL_OUTPUT_DEV_REGISTER(UiGUIFaceRec, ret);
4. Initialisez les gestionnaires :
   • FWK_MANAGER_INIT(VisionAlgoManager, ret);
   • FWK_MANAGER_INIT(OutputManager, ret);
5. Démarrez les gestionnaires :
   • FWK_MANAGER_START(VisionAlgoManager, VISION_ALGO_MANAGER_TASK_PRIORITY, ret);
   • FWK_MANAGER_START(OutputManager, OUTPUT_MANAGER_TASK_PRIORITY, ret);
6. Définir la priorité des tâches du manager :
   • #définir VISION_ALGO_MANAGER_TASK_PRIORITY 3
   • #définir OUTPUT_MANAGER_TASK_PRIORITY 1

Ajouter la prise en charge de la base de données de visages sur le framework
Les données des caractéristiques du visage enregistrées sont accessibles dans la base de données des visages stockée sur Flash via un petit file système. Les étapes pour ajouter la prise en charge de la base de données de visages sont décrites ci-dessous.

Ajouter des pilotes pour le stockage Flash
Copiez le pilote FlexSPI de l'interface Flash files fsl_flexspi.c et fsl_flexspi.h, ainsi que le pilote de chiffrement des données files fsl_caam.c et fsl_caam.h du chemin SDK_2_13_0_MIMXRT1170-EVK\devices \MIMRX1176\drivers\ vers le dossier drivers de l'example SW.

Ajouter un support au niveau du tableau

1. Ajoutez les définitions de FlexSPI utilisées pour le périphérique Flash intégré dans board.h :
   • #définir BOARD_FLEXSPI FLEXSPI1
   • #define BOARD_FLEXSPI_CLOCK kCLOCK_FlexSpi1
   • #définir BOARD_FLEXSPI_AMBA_BASE FlexSPI1_AMBA_BASE
2. Copier les opérateurs et configurations files du périphérique Flash flexspi_nor_flash_ops.c, flexspi_nor_flash_ops.h, sln_flash_config.c, sln_flash_config_w25q256jvs.h et sln_flash_ops.h sous le chemin smart HMI\coffee_machine\cm7\source\flash_config\ vers le tableau de dossiers de l'example SW.
   • Décochez « Exclure la ressource de la build » dans C/C++ Build > Paramètres après avoir cliqué avec le bouton droit sur l'icône files et en ouvrant les propriétés pour permettre leur intégration dans le projet.
3. Changer l'en-tête inclus filenommez sln_flash_config.h en sln_flash_config_w25q256jvs.h dans sln_flash_config.c et flexspi_nor_flash_ops.h.
4. Définissez la source d'horloge FlexSPI1 dans le file clock_config.c faisant référence à l'application de la machine à café.

Ajouter un adaptateur et un support de niveau intermédiaire

1. Copiez le files sln_flash.c, sln_flash.h, sln_encrypt.c et sln_encrypt.h comme pilotes d'adaptateur pour le file système et application depuis le chemin de smart HMI\coffee_machine\cm7\source\ vers le dossier source de l'example. Mettre à jour le nouveau files:
   • Décochez « Exclure la ressource de la construction » pour la construction.
   • Changer tout l'en-tête inclus file nommez sln_flash_config.h en sln_flash_config_w25q256jvs.h.
2. Copiez le dossier filesystème contenant les API pour le petit filesystème et pilote HAL de l'IHM intelligente \coffee_machine\cm7\source\ vers l'example SW. Et mise à jour pour le nouveau dossier :
   • Décochez « Exclure la ressource de la construction » pour la construction.
   • Ajoutez le chemin d'inclusion correspondant dans les paramètres du projet : "${workspace_loc:/${ProjName}/filesystème}"
   • Changer l'en-tête inclus file nommez sln_flash_config.h en sln_flash_config_w25q256jvs.h et fica_definition.h en app_config.h dans le file sln_flash_littlefs.h.
3. Copiez le dossier littlefs contenant le middle ware – little filesystème du chemin SDK_2_13_0_ MIMXRT1170-EVK\middleware\ vers l'example SW. Et mettez à jour le nouveau dossier :
   • Décochez « Exclure la ressource de la construction » pour la construction.
   • Ajoutez le chemin d'inclusion correspondant dans les paramètres du projet : "${workspace_loc:/${ProjName}/littlefs}"

Ajouter des pilotes HAL 

• Il existe deux appareils HAL : file le système et la base de données de visages HAL sont pris en charge pour la fonctionnalité d'accès à la base de données et ils sont déjà implémentés dans le framework sans aucun changement. Activez-les en ajoutant les définitions ci-dessous dans board_define.h :
  • #définir ENABLE_FLASH_DEV_Littlefs
  • #définir ENABLE_FACEDB

Et change le nom de la base de données des visages pour l'example: #define OASIS_FACE_DB_DIR « oasis_gui_face_rec »

Ajouter une prise en charge au niveau de l'application

1. Mettre à jour le principal file lvgl_gui_face_rec_cm7.cpp :
   • Inclure l'en-tête file lié au Flash file gestionnaire HAL du système en ajoutant la ligne de code : #include « fwk_flash.h »
   • Déclarer et enregistrer file dispositif HAL du système :
     • HAL_FLASH_DEV_DECLARE(Petitsfs);
     • HAL_FLASH_DEV_REGISTER(Littlefs, ret);
       Note: Le file Le périphérique système HAL doit être enregistré avant que tous les gestionnaires de périphériques soient initialisés dans la fonction APP_InitFramework().
   • Appelez la fonction BOARD_ConfigMPU() dans APP_BoardInit() pour configurer MPU.
2. Réglez le file affectation du système sur Flash dans le file app_config.h en définissant les définitions de macro utilisées dans le file sln_flash_littlefs.h :
   • #définir FICA_IMG_FILE_SYS_ADDR (FLASH_IMG_SIZE + RES_SHMEM_TOTAL_SIZE)
   • #définir FICA_FILE_SYS_SIZE (0x280000)

Configurations
Certains codes liés à Flash sont exécutés dans la zone SRAM ITC pour des performances suffisantes. Copiez le dossier linkscripts contenant les configurations de l'éditeur de liens du chemin smart HMI\coffee_machine\cm7\ vers le dossier ex.ample SW.

Implémenter une application GUI LVGL
Le développement d'une application GUI LVGL basée sur un framework appelle les API de la sortie UI HAL et fournit les API pour sortir UI HAL (voir la section 4.1.3 pour l'implémentation de la sortie UI HAL).

Cependant, la mise en œuvre détaillée d'une application GUI LVGL dépend des exigences et de la conception de l'application. L'application GUI dans cet example est conçu comme décrit au début de la section Section 4.

Vous trouverez ci-dessous les introductions à la mise en œuvre :

1. Les codes personnalisés sont implémentés dans les fichiers custom.c et custom.h fournis par GUI Guider comme interface entre le projet GUI Guider et le projet de système embarqué.
   •  Ajoutez les nouvelles fonctions nommées gui_xxx() dans custom.c pour obtenir les fonctions ci-dessous :
     • Pour la sortie de l'interface utilisateur HAL et de l'application GUI pour mettre à jour l'interface utilisateur.
     • Pour que l'application GUI déclenche des événements en appelant les fonctions de rappel de l'interface utilisateur à partir de la sortie UI HAL.
       Par exempleample, la nouvelle fonction gui_event_face_rec_action() appelle les fonctions de rappel de l'interface utilisateur pour gérer l'un des événements d'enregistrement du visage, de reconnaissance du visage et de suppression de l'utilisateur déclenchés depuis l'application GUI lorsque le bouton associé est cliqué.
       Remarque : La fonction gui_set_virtual_face() appelée dans la sortie UI HAL pour le préview le mode doit être implémenté dans custom.c :
   •  Clonez la fonction gui_set_virtual_face() depuis smart HMI\coffee_machine\cm4\custom \custom.c.
   •  Changer le nom du widget home_img_cameraPreview à screen_img_camera_preview dans la fonction.
   •  Implémentez les fonctions de rappel de l'interface utilisateur avec le même prototype sur toutes celles de la sortie UI HAL sous le contrôle de la définition de macro #ifndef RT_PLATFORM dans custom.c pour être compatible avec le projet GUI Guider car ces fonctions dans la sortie UI HAL dépendent du plateforme embarquée. Dans custom.c, ils dépendent du simulateur sur le guide GUI et sont indépendants de la plateforme embarquée. Par exempleample, le rappel d'enregistrement de visage est implémenté comme ci-dessous pour le simulateur GUI Guider en cours d'exécution : #ifndef RT_PLATFORM void UI_Registration_Callback() { gui_hide_del_user_btn(true); s_InAction = faux ; retour; }
     Note: Reportez-vous au même prototype de la fonction introduit à l'étape 6 de la section 4.1.3
     La définition de macro RT_PLATFORM est définie dans les paramètres du projet de MCUXpresso, comme le montre la figure 7 :
   • Déclarez toutes les fonctions nommées UI_xxx_Callback() et gui_xxx() dans custom.h et ajoutez custom.h inclus dans smart_tlhmi_event_descriptor.h pour partager les API GUI avec la sortie HAL de l'interface utilisateur.
2. Développer l'interface graphique sur GUI Guider :
   • Cloner le dossier de la caméra avantview contenant le logiciel du projet GUI Guider dans le dossier gui_guider du package logiciel de base lvgl_gui_camera_preview_cm7. Changer le nom associé camera_preview à face_rec pour le nouvel example.
   • Copiez les fichiers custom.c et custom mis à jour ci-dessus. h au nouveau logiciel de projet GUI Guider.
   •  Ouvrez le nouveau projet face_rec sur GUI Guider. Mettre à jour comme ci-dessous :
     • Ajoutez le nouveau bouton intitulé Supprimer l'utilisateur. Ajoutez-y le drapeau Caché pour que le bouton soit masqué au démarrage de l'application GUI.
     • Ajoutez la ligne de code d'appel de l'API gui_event_face_rec_action() avec un paramètre d'ID d'événement différent sur le déclencheur « Publié » dans le paramètre d'événement de tous les boutons Enregistrement, Reconnaissance et Supprimer l'utilisateur pour déclencher les événements d'enregistrement du visage, de reconnaissance du visage et de suppression d'utilisateur. La figure 8 montre le code de l'événement du bouton Enregistrement :
3. Mettez à jour le code généré depuis GUI Guider vers le projet MCUXpresso.
   • Remplacez le contenu à l'exception des images du dossier dans le dossier généré du logiciel du projet MCUXpresso par ceux correspondants dans le dossier généré du logiciel du projet GUI Guider.

Note: Pour plus de détails sur les modifications introduites ci-dessus, consultez l'example logiciel sur https://mcuxpresso.nxp.com/appcodehub.

Vérifications avec l'example projet

Pour avoir l'example progiciel contenant les ressources et outils de cette note d’application, visitez : https://mcuxpresso.nxp.com/appcodehub. Ouvre l'example projet sur l'IDE MCUXpresso. Construire et programmer le .axf file à l'adresse 0x30000000 et programmer le bac à ressources file camera_preview_resource.bin à l'adresse 0x30800000.

L'ex de reconnaissance faciale de l'interface graphique LVGLample fonctionne normalement comme ci-dessous :

• Préview: A la mise sous tension, les flux vidéo capturés par la caméra s'affichent sur la zone spécifique du pré-caméra.view sur l'écran de l'interface graphique. L'étiquette d'état affiche « Preview…». Pour plus de détails, voir la figure 3. Le bouton Supprimer l'utilisateur est masqué. Lorsque vous cliquez sur la zone en dehors des boutons et des images, il affiche le préview indiquer comme ci-dessus après la fin de l’action d’enregistrement ou de reconnaissance du visage.
• Inscription:
  • tartup: Lorsque vous cliquez sur le bouton Enregistrement, l'enregistrement du visage démarre. L'étiquette d'état change pour afficher « Inscription… », le rectangle du guide du visage est bleu et la barre de progression commence à afficher la progression. Assurez-vous que le visage de l'utilisateur apparaît dans le rectangle bleu du guide du visage pour l'enregistrement.
  • succès: L'étiquette d'état indique « Enregistrement… OK » et le numéro d'identification de l'utilisateur enregistré, le rectangle du guide du visage devient rouge si l'enregistrement du visage est réussi avant que la progression ne soit complète sur la barre.
  • Échec -> Délai d'expiration : L'étiquette d'état affiche « Enregistrement… Délai d'expiration » si l'enregistrement du visage échoue toujours lorsque la progression est complète sur la barre.
  • Échec -> Duplication : l'étiquette d'état indique « Enregistrement… Échec », le rectangle du guide du visage devient vert si le visage enregistré est reconnu avant que la progression ne soit complète sur la barre.
• econnaissance:
  • Démarrage : Lorsque vous cliquez sur le bouton Reconnaissance, la reconnaissance faciale démarre. L'étiquette d'état change pour afficher « Reconnaissance… », le rectangle du guide du visage est bleu et la barre de progression commence à afficher la progression. Assurez-vous que le visage de l'utilisateur est affiché dans le rectangle bleu du guide du visage pour l'enregistrement.
  • succès: L'étiquette d'état indique « Reconnaissance… OK » et le numéro d'identification de l'utilisateur reconnu, le rectangle du guide du visage devient vert si la reconnaissance du visage est réussie avant que la progression ne s'affiche complètement sur la barre. À ce moment-là, le bouton Supprimer l'utilisateur apparaît. Cela signifie que l'utilisateur ne peut être supprimé que lorsqu'il est reconnu.
  • ailure: L'étiquette d'état affiche « Reconnaissance… Délai d'expiration » si la reconnaissance faciale échoue toujours lorsque la progression s'affiche complète sur la barre.
• Supprimer l'utilisateur: Lorsque vous cliquez sur le bouton « Supprimer l'utilisateur », une fois la reconnaissance faciale réussie, l'étiquette d'état change pour afficher « Supprimer l'utilisateur… OK » avec le rectangle du guide du visage devenant bleu et la progression affichée pleine sur la barre. Le bouton Supprimer l'utilisateur est à nouveau masqué. Le visage/utilisateur reconnu est supprimé de la base de données. Cela signifie que ce visage/utilisateur ne peut pas être reconnu tant qu'il n'est pas enregistré à nouveau.

Remarque sur le code source dans le document
ExampLe code présenté dans ce document est protégé par les droits d'auteur et la licence BSD-3-Clause suivants :

Copyright 2024 NXP La redistribution et l'utilisation sous forme source et binaire, avec ou sans modification, sont autorisées à condition que les conditions suivantes soient remplies :

1. Les redistributions du code source doivent conserver l'avis de droit d'auteur ci-dessus, cette liste de conditions et la clause de non-responsabilité suivante.
2. Les redistributions sous forme binaire doivent reproduire l'avis de droit d'auteur ci-dessus, cette liste de conditions et la clause de non-responsabilité suivante dans la documentation et/ou d'autres éléments doivent être fournis avec la distribution.
3. Ni le nom du détenteur des droits d'auteur ni les noms de ses contributeurs ne peuvent être utilisés pour approuver ou promouvoir des produits dérivés de ce logiciel sans autorisation écrite préalable spécifique.

CE LOGICIEL EST FOURNI PAR LES TITULAIRES DES DROITS D'AUTEUR ET LES CONTRIBUTEURS « TEL QUEL » ET TOUTE GARANTIE EXPRESSE OU IMPLICITE, Y COMPRIS, MAIS SANS S'Y LIMITER, LES GARANTIES IMPLICITES DE QUALITÉ MARCHANDE ET D'ADÉQUATION À UN USAGE PARTICULIER SONT EXCLUES. EN AUCUN CAS, LE TITULAIRE DU DROIT D'AUTEUR OU LES CONTRIBUTEURS NE SERONT RESPONSABLES DE TOUT DOMMAGE DIRECT, INDIRECT, ACCESSOIRE, SPÉCIAL, EXEMPLAIRE OU CONSÉCUTIF (Y COMPRIS, MAIS SANS S'Y LIMITER, L'ACQUISITION DE BIENS OU SERVICES DE SUBSTITUTION, LA PERTE D'UTILISATION, DE DONNÉES OU DE PROFITS, OU L'INTERRUPTION D'ACTIVITÉ), QUELLE QU'EN SOIT LA CAUSE ET SUR TOUTE THÉORIE DE RESPONSABILITÉ, QU'ELLE SOIT CONTRACTUELLE, STRICTE OU DÉLICTUELLE (Y COMPRIS LA NÉGLIGENCE OU AUTRE) DÉCOULANT DE QUELQUE MANIÈRE QUE CE SOIT DE L'UTILISATION DE CE LOGICIEL, MÊME S'ILS SONT AVISÉS DE LA POSSIBILITÉ DE TELS DOMMAGES.

Historique des révisions

Mentions légales

Définitions
Brouillon — Le statut de brouillon d'un document indique que le contenu est toujours en cours de révision interne.view et sous réserve d'une approbation formelle, ce qui peut entraîner des modifications ou des ajouts. NXP Semiconductors ne fait aucune déclaration ni ne donne aucune garantie quant à l'exactitude ou à l'exhaustivité des informations incluses dans une version préliminaire d'un document et ne sera pas responsable des conséquences de l'utilisation de ces informations.

Clause de non-responsabilité

• Garantie et responsabilité limitées — Les informations contenues dans ce document sont considérées comme exactes et fiables. Cependant, NXP Semiconductors ne donne aucune représentation ou garantie, expresse ou implicite, quant à l'exactitude ou à l'exhaustivité de ces informations et n'assume aucune responsabilité pour les conséquences de l'utilisation de ces informations. NXP Semiconductors décline toute responsabilité quant au contenu de ce document s'il est fourni par une source d'information extérieure à NXP Semiconductors.
  En aucun cas, NXP Semiconductors ne pourra être tenu responsable des dommages indirects, accessoires, punitifs, spéciaux ou consécutifs (y compris, sans s'y limiter, la perte de profits, la perte d'économies, l'interruption d'activité, les coûts liés au retrait ou au remplacement de tout produit ou les frais de reprise) que ce soit ou non, ces dommages sont fondés sur un délit (y compris la négligence), une garantie, une rupture de contrat ou toute autre théorie juridique.
  Nonobstant tout dommage que le client pourrait encourir pour quelque raison que ce soit, la responsabilité globale et cumulative de NXP Semiconductors envers le client pour les produits décrits dans les présentes sera limitée conformément aux conditions générales de vente commerciale de NXP Semiconductors.
• Droit d'apporter des modifications — NXP Semiconductors se réserve le droit d'apporter des modifications aux informations publiées dans ce document, y compris, sans s'y limiter, les spécifications et les descriptions de produits, à tout moment et sans préavis. Ce document annule et remplace toutes les informations fournies avant sa publication.
• Aptitude à l'emploi — Les produits NXP Semiconductors ne sont pas conçus, autorisés ou garantis pour être adaptés à une utilisation dans des systèmes ou équipements vitaux, vitaux ou critiques pour la sécurité, ni dans des applications où la défaillance ou le dysfonctionnement d'un produit NXP Semiconductors peut raisonnablement entraîner des des blessures corporelles, la mort ou des dommages matériels ou environnementaux graves. NXP Semiconductors et ses fournisseurs déclinent toute responsabilité pour l'inclusion et/ou l'utilisation des produits NXP Semiconductors dans de tels équipements ou applications et, par conséquent, une telle inclusion et/ou utilisation est aux risques et périls du client.
• Applications — Les applications décrites ici pour l'un de ces produits sont uniquement à des fins d'illustration. NXP Semiconductors ne fait aucune représentation ou garantie que ces applications seront adaptées à l'utilisation spécifiée sans autre test ou modification.
  Les clients sont responsables de la conception et du fonctionnement de leurs applications et produits utilisant les produits NXP Semiconductors, et NXP Semiconductors décline toute responsabilité pour toute assistance concernant les applications ou la conception des produits du client. Il est de la seule responsabilité du client de déterminer si le produit NXP Semiconductors est adapté et adapté aux applications et produits prévus du client, ainsi qu'à l'application et à l'utilisation prévues du ou des clients tiers du client. Les clients doivent fournir des protections de conception et d'exploitation appropriées pour minimiser les risques associés à leurs applications et produits. NXP Semiconductors décline toute responsabilité liée à tout défaut, dommage, coût ou problème basé sur une faiblesse ou un défaut des applications ou produits du client, ou de l'application ou de l'utilisation par le ou les clients tiers du client. Le client est responsable d'effectuer tous les tests nécessaires pour les applications et les produits du client utilisant les produits de NXP Semiconductors afin d'éviter un défaut des applications et des produits ou de l'application ou de l'utilisation par le(s) client(s) tiers du client. NXP décline toute responsabilité à cet égard.
• Conditions générales de vente commerciale — Les produits NXP Semiconductors sont vendus sous réserve des conditions générales de vente commerciales, telles que publiées sur https://www.nxp.com/profile/conditions, sauf convention contraire dans un accord individuel écrit valide. Dans le cas où un accord individuel est conclu, seules les conditions générales de l'accord respectif s'appliquent. NXP Semiconductors s'oppose expressément par la présente à l'application des conditions générales du client en ce qui concerne l'achat de produits NXP Semiconductors par le client.
• Contrôle des exportations — Ce document ainsi que le(s) article(s) décrit(s) ici peuvent être soumis à des réglementations sur le contrôle des exportations. L'exportation peut nécessiter une autorisation préalable des autorités compétentes.
• Aptitude à l'utilisation dans des produits qualifiés non automobiles — À moins que ce document n'indique expressément que ce produit spécifique de NXP Semiconductors est qualifié pour l'automobile, le produit n'est pas adapté à une utilisation automobile. Il n'est ni qualifié ni testé conformément aux exigences d'essais ou d'applications automobiles. NXP Semiconductors n'accepte aucune responsabilité concernant l'inclusion et/ou l'utilisation de produits non qualifiés pour l'automobile dans des équipements ou des applications automobiles.
  Dans le cas où le client utilise le produit pour la conception et l'utilisation dans des applications automobiles conformément aux spécifications et normes automobiles, le client (a) doit utiliser le produit sans la garantie de NXP Semiconductors sur le produit pour ces applications, utilisations et spécifications automobiles, et ( b) chaque fois que le client utilise le produit pour des applications automobiles au-delà des spécifications de NXP Semiconductors, cette utilisation sera uniquement aux risques du client, et (c) le client indemnise entièrement NXP Semiconductors pour toute responsabilité, dommages ou réclamations de produit échoué résultant de la conception et de l'utilisation par le client de le produit pour les applications automobiles au-delà de la garantie standard de NXP Semiconductors et des spécifications produit de NXP Semiconductors.
• Traductions — Une version non anglaise (traduite) d'un document, y compris les informations juridiques contenues dans ce document, sert uniquement de référence. La version anglaise prévaudra en cas de divergence entre la version traduite et la version anglaise.
• Sécurité — Le client comprend que tous les produits NXP peuvent être sujets à des vulnérabilités non identifiées ou peuvent prendre en charge des normes ou des spécifications de sécurité établies avec des limitations connues. Le Client est responsable de la conception et du fonctionnement de ses applications et produits tout au long de leur cycle de vie afin de réduire l'effet de ces vulnérabilités sur les applications et produits du Client. La responsabilité du client s'étend également à d'autres technologies ouvertes et/ou propriétaires prises en charge par les produits NXP pour une utilisation dans les applications du client. NXP décline toute responsabilité pour toute vulnérabilité. Le client doit vérifier régulièrement les mises à jour de sécurité de NXP et effectuer un suivi approprié. Le client doit sélectionner les produits dotés de fonctionnalités de sécurité qui répondent le mieux aux règles, réglementations et normes de l'application prévue et prendre les décisions de conception ultimes concernant ses produits et est seul responsable du respect de toutes les exigences légales, réglementaires et liées à la sécurité concernant ses produits, indépendamment de toute information ou assistance pouvant être fournie par NXP.

NXP dispose d'une équipe de réponse aux incidents de sécurité des produits (PSIRT) (joignable à l'adresse PSIRT@nxp.com) qui gère l'investigation, le signalement et la publication de solutions pour les vulnérabilités de sécurité des produits NXP.
NXP BV — NXP BV n'est pas une société opérationnelle et ne distribue ni ne vend de produits.

Marques déposées
Avis: Toutes les marques, noms de produits, noms de services et marques déposées référencés sont la propriété de leurs propriétaires respectifs.

NXP — le nom et le logo sont des marques commerciales de 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 — sont des marques commerciales et/ou des marques déposées d'Arm Limited (ou de ses filiales ou sociétés affiliées) aux États-Unis et/ou autre part. La technologie associée peut être protégée par tout ou partie des brevets, droits d'auteur, dessins et secrets commerciaux. Tous les droits sont réservés.

• i.MX — est une marque déposée de NXP BV
• J-Link — est une marque commerciale de SEGGER Microcontroller GmbH.

Microsoft, Azure et ThreadX sont des marques commerciales du groupe de sociétés Microsoft.

Veuillez noter que des avis importants concernant ce document et le(s) produit(s) décrit(s) dans ce document ont été inclus dans la section « Informations légales ».

© 2024 NXP BV
Pour plus d'informations, veuillez visiter : https://www.nxp.com

• Date de sortie: 19 avril 2024
• Identifiant du document:AN14263

FAQ

Q : Quel est l’objectif principal de ce produit ?
R : L'objectif principal est d'activer la fonction de reconnaissance faciale à l'aide d'un modèle d'algorithme de vision AI&ML avec une simple interface graphique LVGL ex.ample sur la carte SLN-TLHMI-IOT.

Q : Comment les développeurs peuvent-ils bénéficier de cette note d'application ?
R : Les développeurs peuvent apprendre étape par étape comment implémenter la reconnaissance faciale sur le framework à l'aide de l'ex fourni.ample et comprendre les gestionnaires de périphériques, les périphériques HAL et les mécanismes d'événements impliqués.

Documents / Ressources

NXP AN14263 Implémenter la reconnaissance faciale de l'interface graphique LVGL sur Framewor [pdf] Guide de l'utilisateur AN14263 Implémenter la reconnaissance faciale LVGL GUI sur Framewor, AN14263, Implémenter la reconnaissance faciale LVGL GUI sur Framewor, LVGL GUI Reconnaissance faciale sur Framewor, Reconnaissance faciale sur Framewor, Reconnaissance sur Framewor, Framewor

Références

• Manuel d'utilisation