EUR | USD

Implemente rapidamente o reconhecimento facial resistente a spoofing sem uma conexão à nuvem

By Stephen Evanczuk

Contributed By Digi-Key's North American Editors

O reconhecimento facial ganhou larga aceitação para autenticar acesso aos smartphones, porém tentar aplicar esta tecnologia de forma abrangente fica aquém das expectativas em outras áreas, apesar da sua eficácia e facilidade de uso. Junto com os desafios técnicos de implementação confiável, soluções econômicas de aprendizado de máquina, os desenvolvedores devem endossar preocupações de usuário acerca da confiabilidade e privacidade dos métodos convencionais de reconhecimento facial, que dependem das conexões de nuvem vulneráveis à falsificação ou “spoofing”.

Este artigo discute a dificuldade de autenticação segura antes de introduzir uma solução de hardware e software da NXP Semiconductors que aborda os problemas. Em seguida, mostra como os desenvolvedores sem experiência anterior em métodos de aprendizado de máquina, podem usar a solução para implementar de forma rápida reconhecimento facial off-line anti-spoofing em um produto inteligente.

Os desafios de autenticação segura para produtos inteligentes

Ao endossar preocupações crescentes sobre a segurança de produtos inteligentes, os desenvolvedores deixam a si mesmos com poucas opções convincentes para autenticação confiável de usuários que procuram por acesso rápido e seguro. As formas tradicionais contam com métodos de autenticação multifatores, que apóiam-se em algumas combinações de três fatores clássicos para autenticar: “algo que você conhece”, como uma senha; “algo que você possui”, como uma chave física ou cartão-chave e “algo que você é”, que normalmente é um fator biométrico como uma impressão digital ou íris. Ao usar essa abordagem, uma fechadura de porta fortemente autenticada pode precisar que o usuário digite uma senha, use um cartão-chave e forneça ainda uma impressão digital para abrir a porta. Na prática, essas exigências rigorosas são aborrecimentos ou simplesmente impraticáveis para os usuários que precisam se reautenticarem de forma frequente e fácil com um smartphone ou outro dispositivo usado habitualmente.

O uso de reconhecimento facial torna a autenticação simplificada de forma convincente para os usuários de smartphone, porém alguns de seus recursos podem não estar disponíveis em todos os dispositivos. Além do poder de processamento notável disponível nos smartphones de última geração, a conectividade sempre ativa é uma exigência fundamental para fornecimento de uma gama sofisticada de serviços, esperados de forma habitual pelos seus usuários.

Para muitos produtos que precisam de autenticação segura, a plataforma de operação subjacente fornecerá, em geral, recursos de computação mais modestos e com conectividade mais limitada. Os serviços de reconhecimento facial dos principais provedores de serviços em nuvem deslocam a carga de processamento para a nuvem, porém a necessidade de conectividade robusta para garantir latência mínima de resposta, talvez imponha exigências que vão além da capacidade da plataforma. Com preocupação igual ou maior aos usuários, transmitir as imagens através de redes públicas para processamento e possivelmente armazená-las na nuvem aumenta ainda mais os problemas de privacidade.

Ao usar os processadores i.MX RT106F e software associado da NXP Semiconductors, os desenvolvedores podem implementar atualmente o reconhecimento facial off-line que aborda essas questões de forma direta.

Hardware e software para reconhecimento facial off-line à prova de fraude

Parte da família de microcontrolador (MCU) Crossover NXP i.MX RT1060, a série NXP i.MX RT106F foi concebida especialmente para suportar fácil integração do reconhecimento facial off-line em dispositivos domésticos inteligentes, eletrodomésticos, dispositivos de segurança e equipamento industrial. Baseado em um núcleo de processador Arm® Cortex®-M7, os processadores trabalham a 528 megahertz (MHz) para grau industrial MIMXRT106FCVL5B, ou 600 MHz para processadores de grau comercial como o MIMXRT106FDVL6A e MIMXRT106FDVL6B.

Além de suportar uma ampla variedade de interfaces externas de memória, os processadores i.MX RT106F incluem 1 Mbyte de memória de acesso aleatório no chip, com 512 Kbytes configurada como RAM de uso geral e 512 Kbytes que pode ser configurada como RAM de uso geral ou como memória fortemente acoplada (TCM) para instruções (I-TCM) ou dados (D-TCM). Junto com o gerenciamento de energia no chip, esses processadores oferecem um conjunto extenso de recursos integrados para controle gráfico, de segurança, de sistema e de interfaces digitais e analógicas, normalmente necessárias para dar suporte aos dispositivos de consumo, interfaces homem-máquina (IHM) e controle de motor (figura 1).

Diagrama dos processadores i.MX RT106F da NXP Semiconductor (clique para ampliar)Figura 1: os processadores i.MX RT106F da NXP Semiconductor combinam um conjunto completo de blocos funcionais necessários para dar suporte ao reconhecimento facial para produtos de consumo, industriais e de segurança. (Fonte da imagem: NXP)

Embora semelhante a outros membros da família i.MX RT1060, os processadores i.MX RT106F inclui uma licença de tempo de execução para o software de reconhecimento facial Oasis Lite da NXP. Projetado para inferência de velocidade nesta classe de processadores, o ambiente de tempo de execução Oasis Lite realiza detecção facial, reconhecimento e ainda classificação emocional com limitação, usando modelos de inferência de rede neural (NN) que executam sobre um mecanismo de inferência e MiniCV — uma versão básica da biblioteca de visão computacional OpenCV de código aberto. O mecanismo de inferência embutido numa biblioteca NXP NN e biblioteca Arm Cortex Microcontroller System Interface Standard NN (CMSIS-NN) (figura 2).

Diagrama da biblioteca de tempo de execução NXP Oasis LiteFigura 2: a biblioteca de tempo de execução NXP Oasis Lite inclui um núcleo Oasis Lite que usa MiniCV e mecanismo de inferência NXP embutido em bibliotecas de rede neural da NXP e Arm. (Fonte da imagem: NXP)

O modelo de inferência reside na plataforma i.MX RT106F, assim a detecção e reconhecimento facial trabalha de forma local, ao contrário de outras soluções que dependem dos recursos baseados em nuvem para executar os algoritmos de aprendizado de máquina. Graças a esta capacidade de reconhecimento facial off-line, os projetistas de produtos inteligentes podem garantir autenticação segura e privada, apesar da baixa largura de banda ou conectividade irregular com a Internet. Além disso, a autenticação ocorre de forma rápida com essa combinação de hardware e software, que precisa menos do que 800 ms para o processador acordar do modo em espera de baixo consumo e completar o reconhecimento facial.

O tempo de execução Oasis Lite, usado com o processador i.MX RT106F, simplifica a implementação do reconhecimento facial off-line de produtos inteligentes, mas é claro que o processador e o ambiente de tempo de execução são apenas parte obrigatória de uma solução de sistema. Além de um conjunto mais completo dos componentes de sistema, uma solução de autenticação eficaz exige capacidade de captura de imagem que pode mitigar um tipo de ameaça de segurança chamada ataques de apresentação. Esses ataques tentam enganar a autenticação do reconhecimento facial através de fotografias. Para desenvolvedores que procuram implantar de forma rápida a autenticação baseada no rosto nos seus próprios produtos, o kit de desenvolvimento NXP SLN-VIZNAS-IOT e software associado fornece uma plataforma pronta para uso em avaliação, prototipagem e desenvolvimento de reconhecimento facial anti-spoofing.

Solução completa de sistemas seguros para reconhecimento facial

Como a maioria dos processadores avançados, o processador i.MX RT106F exige poucos componentes adicionais para fornecer uma plataforma de computação eficaz. O kit NXP SLN-VIZNAS-IOT finaliza o projeto através da integração do i.MX RT106F com dispositivos adicionais para fornecer uma plataforma de hardware completa. (figura 3).

Diagrama do kit NXP SLN-VIZNAS-IOT (clique para ampliar)Figura 3: o kit NXP SLN-VIZNAS-IOT inclui um módulo conectado que fornece uma plataforma robusta de sistema conectado necessária para executar o software de autenticação. (Fonte da imagem: NXP)

A placa do módulo conectado do kit combina um processador NXP MIMXRT106FDVL6A i.MX RT106F, um elemento seguro NXP A71CH e duas opções de conectividade: sistema em chip (SoC) Bluetooth de baixa energia (BLE) MKW41Z512VHT4 Kinetis KW41Z da NXP e módulo Wi-Fi/Bluetooth da Murata Electronics, o LBEE5KL1DX-883.

Para complementar a memória em chip do processador, o módulo conectado agrega uma RAM dinâmica síncrona (SDRAM) de 256 Mbits W9825G6JB da Winbond Electronics, e da Integrated Silicon Solution. Inc. (ISSI) vem uma memória flash NOR de 256 Mbits IS26KL256S-DABLI00, além de um dispositivo de Interface Periférica Serial (SPI) quad de 256 Mbits IS25LP256D da ISSI.

Finalmente, o módulo inclui um conversor buck XCL214B333DR da Torex Semiconductor para complementar a capacidade de gerenciamento interno de energia do processador i.MX RT106F para os dispositivos adicionais na placa do módulo conectado.

Por sua vez, o módulo conectado é montado sobre uma placa de aplicação de visão que combina um sensor infravermelho passivo (PIR) IRA-S210ST01 da Murata Electronics, sensor de movimento, carregador de bateria, suporte de áudio, diodos emissores de luz (LEDs), botões e conectores de interface (figura 4).

Imagem do kit NXP SLN-VIZNAS-IOT (clique para ampliar)Figura 4: no kit NXP SLN-VIZNAS-IOT, o módulo conectado (à esquerda) é anexado à placa de aplicação de visão para fornecer a base de hardware para o reconhecimento facial. (Fonte da imagem: NXP)

Além desta plataforma de sistema, um projeto de sistema de reconhecimento facial exige de forma clara um sensor de câmera adequado para capturar uma imagem do rosto do usuário. Como citado anteriormente, contudo, as preocupações sobre ataques de apresentação exigem recursos de captura de imagem adicionais.

Mitigando ataques de apresentação

Os pesquisadores exploraram durante anos diferentes métodos de detecção de ataque de apresentação (PAD), projetados para mitigar tentativas como o uso de impressão digital disfarçada ou imagens do rosto para burlar os sistemas de autenticação baseados em biometria. Embora os detalhes estão além do escopo deste artigo, os métodos PAD em geral usam análises profundas da qualidade e características dos dados biométricos capturados como parte do processo, assim como métodos de detecção de “vivacidade”, projetados para determinar se os dados biométricos foram capturados a partir de uma pessoa viva. Por trás de muitos desses diferentes métodos, os modelos de redes neurais profundas (DNN) desempenham um papel importante não apenas no reconhecimento facial, mas também na identificação de tentativas de burlar o sistema. No entanto, o sistema de imagem usado para capturar o rosto do usuário pode dar suporte adicional de detecção de vivacidade.

Para o kit SLN-VIZNAS-IOT, a NXP inclui módulos de câmera que contém um par de sensores de imagem MT9M114 da ON Semiconductor. Nele, uma câmera é equipada com um filtro vermelho, verde e azul (RGB), além de outra câmera que está instalada com um filtro infravermelho (IV). Anexada por meio de interfaces da câmera à placa de aplicação de visão, a câmera RGB gera uma imagem normal de luz visível, enquanto que a câmera IV captura uma imagem que seria diferente de uma pessoa viva comparada à imagem da pessoa. Ao usar esta abordagem de detecção de vivacidade junto com a capacidade interna de reconhecimento facial, o kit SLN-VIZNAS-IOT fornece recurso de reconhecimento facial anti-spoofing e off-line num invólucro que mede cerca de 30 x 40 mm (figura 5).

Imagem do kit de hardware NXP SLN-VIZNAS-IOTFigura 5: o kit de hardware NXP SLN-VIZNAS-IOT integra um sistema duplo de câmera para detecção de vivacidade (acima) e uma placa de aplicação de visão (abaixo) com um módulo conectado para fornecer uma solução fortuita para reconhecimento facial off-line com capacidade anti-spoofing. (Fonte da imagem: NXP)

Início rápido com o kit SLN-VIZNAS-IOT

O kit NXP SLN-VIZNAS-IOT vem pronto para uso com modelos de reconhecimento facial embutidos. Os desenvolvedores conectam num cabo USB e apertam um botão no kit para realizar um simples registro facial manual usando a aplicação pré-carregada “elock” e o aplicativo móvel que o acompanha (figura 6, à esquerda). Após o registro, o aplicativo móvel exibirá uma mensagem “seja bem-vindo” e rótulo “desbloqueado” assim que o kit autentica o rosto registrado (figura 6, à direita).

Imagem do kit de hardware NXP SLN-VIZNAS-IOT que está pronto para usoFigura 6: o kit de hardware NXP SLN-VIZNAS-IOT está pronto para uso, utilizando um aplicativo complementar para registrar um rosto (à esquerda) e reconhecer rostos registrados (à direita). (Fonte da imagem: NXP)

O software de reconhecimento facial Oasis Lite do kit processa modelos a partir do seu banco de dados de até 3000 rostos RGB com uma precisão de reconhecimento de 99,6%, e até 100 rostos IV com uma precisão anti-spoofing de 96,5%. Conforme mencionado antes, a solução de hardware/software da NXP precisa de menos de um segundo (s) para realizar a detecção facial, alinhamento da imagem, verificação de qualidade, detecção de vivacidade e reconhecimento sobre um alcance de 0,2 a 1,0 metro (m). Na verdade, o sistema suporta um modelo de inferência de “luz” alternativa, capaz de realizar esta mesma sequência em menos do que 0,5 s, porém suporta um tamanho de banco de dados máximo menor de 1000 rostos RGB e 50 rostos IV.

Criando aplicações personalizadas de reconhecimento facial

Ao usar como está, o kit NXP SLN-VIZNAS-IOT permite aos desenvolvedores avaliar, prototipar e desenvolver aplicações de reconhecimento facial de forma rápida. Ao criar soluções personalizadas de hardware, o kit serve como um design de referência completo com todos os esquemas e uma lista de materiais (BOM) detalhada. Para desenvolvimento de software, os programadores podem usar o ambiente de desenvolvimento integrado (IDE) NXP MCUXpresso com suporte FreeRTOS e ferramentas de configuração. Para esta aplicação, os desenvolvedores usam simplesmente o MCUXpresso SDK Builder on-line da NXP para configurar seu ambiente de desenvolvimento de software com VIZNAS SDK da NXP, que inclui o mecanismo de visão de aprendizado de máquina NXP Oasis Lite (figura 7).

Diagrama da NXP que fornece um ambiente de software abrangenteFigura 7: a NXP fornece um ambiente de software abrangente que executa a biblioteca de tempo de execução NXP Oasis Lite e utilitário middleware no sistema operacional FreeRTOS. (Fonte da imagem: NXP)

O pacote de software inclui o código-fonte completo para o ambiente operacional, assim como o aplicativo de exemplo elock citado anteriormente. A NXP não fornece código-fonte para seus mecanismos proprietários Oasis Lite ou para os modelos. Em vez disso, os desenvolvedores trabalham com a biblioteca de tempo de execução Oasis Lite usando uma interface de programação de aplicativo (API) fornecida, que inclui um conjunto de chamadas de funções intuitivas para realizar operações com suporte. Além disso, os desenvolvedores usam um conjunto fornecido de definições e estrutura em C para especificar vários parâmetros, que incluem tamanho da imagem, alocação de memória, retornos de chamada e funções habilitadas usadas pelo sistema quando inicia o ambiente de tempo de execução Oasis Lite (listagem 1).

Copiar
typedef struct {
    //max input image height, width and channel, min_face: minimum face can be detected
    int height;
    int width;
  
    //only valid for RGB images; for IR image, always GREY888 format
    OASISLTImageFormat_t img_format;
    OASISLTImageType_t img_type;
  
    //min_face should not smaller than 40
    int min_face;
  
    /*memory pool pointer, this memory pool should only be used by OASIS LIB*/
    char* mem_pool;
  
    /*memory pool size*/
    int size;
  
    /*output parameter,indicate authenticated or not*/
    int auth;
  
    /*callback functions provided by caller*/
    InfCallbacks_t cbs;
  
    /*what functions should be enabled in OASIS LIB*/
    uint8_t enable_flags;
  
    /*only valid when OASIS_ENABLE_EMO is activated*/
    OASISLTEmoMode_t emo_mode;
  
    /*false accept rate*/
    OASISLTFar_t false_accept_rate;
  
    /*model class */
    OASISLTModelClass_t mod_class;
  
} OASISLTInitPara_t;

Listagem 1: os desenvolvedores podem modificar parâmetros de execução de software ao alterar o conteúdo das estruturas, tal como mostrado aqui para inicialização do tempo de execução Oasis Lite. (Código-fonte: NXP)

O código do aplicativo de exemplo elock demonstra os padrões principais de projeto para iniciar o Oasis como uma tarefa que trabalha sob FreeRTOS, inicializando o ambiente e entrando no seu estágio normal de execução. Neste estágio, o ambiente de tempo de execução funciona sobre cada quadro de uma imagem, executando as funções fornecidas de retorno de chamada, associadas com cada evento definido no ambiente (listagem 2).

Copiar
typedef enum {
    /*indicate the start of face detection, user can update frame data if it is needed.
     * all parameter in callback parameter is invalid.*/
    OASISLT_EVT_DET_START,
  
    /*The end of face detection.
     *if a face is found, pfaceBox(OASISLTCbPara_t) indicated the rect(left,top,right,bottom point value)
     *info and landmark value of the face.
     *if no face is found,pfaceBox is NULL, following event will not be triggered for current frame.
     *other parameter in callback parameter is invalid */
    OASISLT_EVT_DET_COMPLETE,
  
    /*Face quality check is done before face recognition*/
    OASISLT_EVT_QUALITY_CHK_START,
    OASISLT_EVT_QUALITY_CHK_COMPLETE,
  
    /*Start of face recognition*/
    OASISLT_EVT_REC_START,
  
    /*The end of face recognition.
     * when face feature in current frame is gotten, GetRegisteredFaces callback will be called to get all
     * faces feature registered and OASIS lib will try to search this face in registered faces, if this face
     * is matched, a valid face ID will be set in callback parameter faceID and corresponding simularity(indicate
     * how confidence for the match) also will be set.
     * if no face match, a invalid(INVALID_FACE_ID) will be set.*/
    OASISLT_EVT_REC_COMPLETE,
  
    /*start of emotion recognition*/
    OASISLT_EVT_EMO_REC_START,
  
    /*End of emotion recognition, emoID indicate which emotion current face is.*/
    OASISLT_EVT_EMO_REC_COMPLETE,
  
    /*if user set a registration flag in a call of OASISLT_run and a face is detected, this two events will be notified
     * for auto registration mode, only new face(not recognized) is added(call AddNewFace callback function)
     * for manu registration mode, face will be added forcely.
     * for both cases, face ID of new added face will be set in callback function */
    OASISLT_EVT_REG_START,
    /*when registration start, for each valid frame is handled,this event will be triggered and indicate
     * registration process is going forward a little.
     * */
    OASISLT_EVT_REG_IN_PROGRESS,
    OASISLT_EVT_REG_COMPLETE,
    OASISLT_EVT_NUM
  
} OASISLTEvt_t;

Listagem 2: o tempo de execução Oasis Lite reconhece uma série de eventos documentados como um conjunto enumerado no arquivo de cabeçalho do tempo de execução Oasis Lite. (Código-fonte: NXP)

O aplicativo de exemplo pode fornecer aos desenvolvedores mensagens com depuração passo a passo, que descrevem os resultados associados com cada evento processado pelo manipulador de eventos (EvtHandler). Por exemplo, após a conclusão da verificação de qualidade (OASISLT_EVT_QUALITY_CHK_COMPLETE), o sistema imprime mensagens de depuração que descrevem o resultado, e após a conclusão do reconhecimento facial (OASISLT_EVT_REC_COMPLETE), o sistema extrai o ID e nome de usuário a partir de seu banco de dados dos rostos reconhecidos e imprime esta informação (listagem 3).

Copiar
static void EvtHandler(ImageFrame_t *frames[], OASISLTEvt_t evt, OASISLTCbPara_t *para, void *user_data)
{
[code redacted for simplification]
        case OASISLT_EVT_QUALITY_CHK_COMPLETE:
        {
            UsbShell_Printf("[OASIS]:quality chk res:%d\r\n", para->qualityResult);
  
            pQMsg->msg.info.irLive  = para->reserved[5];
            pQMsg->msg.info.front   = para->reserved[1];
            pQMsg->msg.info.blur    = para->reserved[3];
            pQMsg->msg.info.rgbLive = para->reserved[8];
  
            if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_OK_WITHOUT_GLASSES ||
                para->qualityResult == OASIS_QUALITY_RESULT_FACE_OK_WITH_GLASSES)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:ok!\r\n");
            }
            else if (OASIS_QUALITY_RESULT_FACE_SIDE_FACE == para->qualityResult)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:side face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_TOO_SMALL)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:Small Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_BLUR)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: Blurry Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FAIL_LIVENESS_IR)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: IR Fake Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FAIL_LIVENESS_RGB)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: RGB Fake Face!\r\n");
            }
        }
        break;
[code redacted for simplification]
        case OASISLT_EVT_REC_COMPLETE:
        {
            int diff;
            unsigned id                     = para->faceID;
            OASISLTRecognizeRes_t recResult = para->recResult;
  
            timeState->rec_comp = Time_Now();
            pQMsg->msg.info.rt  = timeState->rec_start - timeState->rec_comp;
            face_info.rt        = pQMsg->msg.info.rt;
#ifdef SHOW_FPS
            /*pit timer unit is us*/
            timeState->rec_fps++;
            diff = abs(timeState->rec_fps_start - timeState->rec_comp);
            if (diff > 1000000 / PIT_TIMER_UNIT)
            {
                // update fps
                pQMsg->msg.info.recognize_fps = timeState->rec_fps * 1000.0f / diff;
                timeState->rec_fps            = 0;
                timeState->rec_fps_start      = timeState->rec_comp;
            }
#endif
            memset(pQMsg->msg.info.name, 0x0, sizeof(pQMsg->msg.info.name));
  
            if (recResult == OASIS_REC_RESULT_KNOWN_FACE)
            {
                std::string name;
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face id:%d\r\n", id);
                DB_GetName(id, name);
                memcpy(pQMsg->msg.info.name, name.c_str(), name.size());
                face_info.recognize = true;
                face_info.name      = std::string(name);
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face id:%d name:%s\r\n", id, pQMsg->msg.info.name);
            }
            else
            {
                // face is not recognized, do nothing
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face unrecognized\r\n");
                face_info.recognize = false;
            }
  
            VIZN_RecognizeEvent(gApiHandle, face_info);
        }
        break;

Listagem 3: como mostrado neste fragmento de um aplicativo de exemplo na distribuição de software da NXP, um manipulador de eventos processa os eventos encontrados durante a sequência de reconhecimento facial. (Código-fonte: NXP)

Além de dar suporte às exigências de processamento de reconhecimento facial, o software SLN-VIZNAS-IOT da NXP é projetado para proteger o ambiente operacional. Para garantir a segurança do tempo de execução, o sistema é projetado para verificar a integridade e autenticidade de cada imagem carregada com assinatura no sistema, usando um certificado armazenado no sistema de arquivos do kit SLN-VIZNAS-IOT. Como essa sequência de verificação começa com um carregador de inicialização armazenado na memória somente de leitura (ROM), esse processo fornece uma cadeia de confiança para executar o firmware do aplicativo. Além disso, por causa da possibilidade de desenvolvimento lento da verificação e assinatura de código, esse processo de verificação é projetado para ser ignorado durante o projeto e depuração do software. Na verdade, o kit SLN-VIZNAS-IOT vem pré-carregado com imagens assinadas, mas a verificação de assinatura do código é ignorada por padrão. Os desenvolvedores podem definir opções de forma fácil para habilitar a verificação completa da assinatura de código para fins de produção.

Junto com o ambiente de tempo de execução e o código do aplicativo de exemplo associado, a NXP fornece aplicativos móveis para Android com código-fonte completo em Java. Um dos aplicativos, o VIZNAS FaceRec Manager, fornece uma interface simples para registrar rostos e gerenciar usuários. Outro aplicativo, o VIZNAS Companion, permite aos usuários suprir o kit com credenciais Wi-Fi usando uma conexão existente de Wi-Fi ou BLE.

Conclusão

O reconhecimento facial oferece uma abordagem eficaz para acesso autenticado aos produtos inteligentes, mas implementar isso requer, em geral, computação local de alto desempenho ou conectividade de alta largura de banda sempre ativa para respostas rápidas. Ele também é alvo de spoofing e está sujeito a questões sobre privacidade de usuário.

Como mostrado, um processador especial e biblioteca de software da NXP Semiconductors oferece uma abordagem alternativa, que pode realizar com precisão o reconhecimento facial off-line em menos do que um segundo, sem uma conexão à nuvem, ao mesmo tempo que mitiga tentativas de fraude por spoofing.

Disclaimer: The opinions, beliefs, and viewpoints expressed by the various authors and/or forum participants on this website do not necessarily reflect the opinions, beliefs, and viewpoints of Digi-Key Electronics or official policies of Digi-Key Electronics.

About this author

Stephen Evanczuk

Stephen Evanczuk has more than 20 years of experience writing for and about the electronics industry on a wide range of topics including hardware, software, systems, and applications including the IoT. He received his Ph.D. in neuroscience on neuronal networks and worked in the aerospace industry on massively distributed secure systems and algorithm acceleration methods. Currently, when he's not writing articles on technology and engineering, he's working on applications of deep learning to recognition and recommendation systems.

About this publisher

Digi-Key's North American Editors