NXP AN14270 Adding Voice Support to GUI Guider User Guide

GUI Guider: A user interface development tool from NXP that uses LVGL graphics library to create high-quality displays with various widgets, animations, and styles.

Voice Intelligent Technology (VIT): A tool by NXP for defining wakewords and commands through free online tools and voice control software.

Message Queue (MQUEUE): Implements POSIX 1003.1b message queues for inter-process communication between GUI Guider and VIT.

Hardware, Software, and Host Requirements

Category	Description
Hardware	As per product requirements
Software	As per product requirements
Host	As per product requirements

Product Usage Instructions

Pre-requirements

Flashing Linux Version

To flash the EVK with Linux version:

$ ./uuu.exe -b emmc_all .sd-flash_evk imx-image-full-imx93evk.wic

Toolchain with Yocto Project

Create a bin folder: $ mkdir ~/bin

Download repo tool: $ curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
Add bin folder to PATH variable: $ export PATH=~/bin:$PATH

Clone recipes: $ mkdir imx-yocto-bsp $ cd imx-yocto-bsp $ repo init -u https://github.com/nxp-imx/imx-manifest -b imx-linux-mickledore -m imx-6.1.55-2.2.0.xml $ repo sync
To build and configure: $ DISTRO=fsl-imx-fb MACHINE=imx93evk source imx-setup-release.sh -b deploy

Frequently Asked Questions (FAQ)

Q: What is VIT?
A: VIT stands for Voice Intelligent Technology, a tool by NXP for defining wakewords and commands using online tools and voice control software.

Q: What is GUI Guider?
A: GUI Guider is a user interface development tool from NXP that uses LVGL graphics library to create high-quality displays with various widgets, animations, and styles.

Document information

Information	Content
Keywords	AN14270, VIT, speech recognition, inter-process communication (IPC), message queue, GUI Guider
Abstract	This application note explores the possibility of integrating voice by creating a bridge between a speech recognition technology, such as VIT, and the interface creator GUI Guider.

Introduction

The user interface has limited the use of the tool GUI Guider. Getting an interaction only through a mouse or touchscreen can be enough for some use cases. However, sometimes the use case requires to go beyond its limitations. This document explores the possibility of integrating voice by creating a bridge between a speech recognition technology, such as VIT, and the interface creator GUI Guider. It uses a universal way to link all the voice recognition commands and a wakeword to any interaction created by GUI Guider.

Overview

To set the communication between GUI Guider and VIT technology commands, refer to Section 8. The communication is build using a code created as a handler, which listens and enables it to simulate events in the GUI to create the interaction.

GUI Guider
GUI Guider is a user interface development tool from NXP that provides a fast option to create a high-quality display using the LVGL graphics library. It uses a different variety of widgets, animations, and styles, with different trigger configurations and customization with the possibility of not coding. For more information on GUI Guider, refer to GUI Guider v1.6.1 User Guide (document GUIGUIDERUG).

Voice intelligent technology
Voice Intelligent Technology (VIT) is a tool created by NXP to define wakewords and commands using free online tools, library, and voice control software package. MCUXpresso can use it for micro-controllers or Linux BSP can use it for micro-processors.

Message queue
Message queue (MQUEUE) is a manager that implements the format POSIX 1003.1b message queues. It is used as inter-process communication (IPC) to create the bridge between GUI Guider and VIT. It exchanges data in the form of messages, sending it through VIT and performing the management with the script
command_handler.

Hardware, software, and host requirements

Table 1 provides details of the hardware, software, and host required to use VIT and GUI Guider.

Table 1. Hardware, software, and host used

Category	Description
Hardware	• i.MX 93 EVK • Power supply: USB Type-C 45 W power-delivery supply (5 V/3 A) • USB Type-C male to USB Type-A male cable: assembly, USB 3.0 compliant • LVDSL adapter and HDMI cable or DY1212W-4856 LVCD LCD panel • Internal i.MX 93 microphone
Software	• Linux BSP version: L6.1.55_2.2.0 • GUI Guider v1.6.1 version onward • Toolchain 6.1-Langdale
Host	• X86_64 Linux Ubuntu 20.04.6 LTS

Pre-requirements

This section describes the installation of different tools required.

Flashing Linux version

Before following the below steps, change the boot configuration to the download mode and connect a USB through the host. For more information, refer to i.MX Linux User’s Guide (document IMXLUG).

To flash the EVK, perform the following steps:

Download the recent NXP Linux BSP image release for i.MX 93 (L6.1.55_2.2.0 or latest).
To flash the EVK, download the recent UUU: https://github.com/nxp-imx/mfgtools/releases.
Connect the EVK with the host using EVK port USB1.
Using the imx-image-full, place both programs in the same file and flash the EVK using the following command:

Alternatively, use only the image to flash the EVK:

Note: Ensure to check the boot pins.

Toolchain with Yocto project
Yocto project is an open source collaboration that helps to create custom Linux-based systems. Yocto creates the image used by i.MX.
Ensure that the host machine has an application development toolkit (ADT) or toolchain to have the same environment as the EVK. Ensure it is able to compile applications for the target board. To get the correct toolchain, refer to “section 4.5.12” in i.MX Linux Users Guide (document IMXLUG) and “section 4” in i.MX Yocto Project Users Guide (document IMXLXYOCTOUG).

To get the toolchain on the host machine from the Yocto environment, perform the following steps:

Create a bin folder in the home directory:
Ensure that the ~/bin folder is in the PATH variable.
Clone the recipes to use in the repository:

To build, configure as follows:
To generate the toolchain, set up a standalone environment without the Yocto Project as follows:

GUI Guider

This section explains about GUI Guider and how to use the basics to create a project based on this tool. It also explains about the different characteristics to use and take advantage of those characteristics.

Gui Guider widgets and events
When the user creates a project in GUI Guider, the use of different widgets is assigned as an object generated automatically. This object has different properties; one of them is the Events. Depending on the widget, the events can have different triggers, and what happens depend on the target. For example, Figure 1 shows what happens if a button targets the screen to have only the action “Load screen”.

These objects can be found in the path <Project path>/generated/gui-guider.h. The script command_handler takes advantage of the events used by the widgets simulating the trigger.
For more information on widgets and events, refer GUI Guider v1.6.1 User Guide (document GUIGUIDERUG).

Quick start
To start working, install the GUI Guider.

On host installation, perform the following steps:

Download the most recent version of GUI Guider (1.7.1 or latest).

Follow the steps to download.
Here, the user can choose to create a project with official examples or the local projects.

To create a GUI project, perform the following steps:

Open GUI Guider 1.7.1.

Create a project.
Select the LVGL version.
For i.MX 93, select the i.MX processor.

Select a template. For this document, choose the “ScreenTransition” template.
Choose a Project Name and to create a project, click Create.
The main window must appear, as shown in Figure 6.

Creating widgets, events, and triggers

To create widgets, events, and triggers, perform the following steps:

On the left-side of the GUI Guider, click the button, highlighted in red, two times.

As a result, the button expands to show all the available widgets.
There can be various widgets with different properties. This application note focuses on the widget type button. However, there can be other types of widgets with their limitations. For more information, refer to “Widget details” in GUI Guider v1.6.1 User Guide (document GUIGUIDERUG).
Add the Button widget by dragging it to the UI from the widgets tab.
Right-click on the Button for the properties and click Add event.

A window pops up showing all the events the widget can trigger.
Next, the window show all the events the trigger can fire. These events can be applied to screens, other widgets, or creating custom events.
For this example, a new screen is loaded. Click the load screen and select the screens to be loaded.

To test the application, use the simulator integrated with GUI Guider. It is used to select the next button and the type of simulation to use. For this case, use a simulator in C.
To load the new screen, click Button.

Building for i.MX 93

To build i.MX 93, perform the following steps:

Ensure that the toolchain used by GUI Guider has been installed correctly. To cross-verify, check the path

From the previous example, to create the application and run it on i.MX 93, select Project > Build > Yocto from the top bar.
To check the status of Project, Binary size, and Log, select the Information tab at the bottom of the application. Check the log by expanding the Information tab.
The log provides building information including the location of the binary file. For this case, the binary is in the path /<GUI-Guider project path>/build/gui_guider.

Locate the host terminal and send it to the EVK using the following command:
Note: To use the above approach, it is necessary that both the machines, host, and target are on the same network and the board IP is known.
Execute the binary file on the EVK using the following command:
For example, using an LVDS screen, which shows the project built by GUI Guider, as shown in Figure 19.

VIT

This section explains how to use VIT standalone and generate the model to link it with the GUI Guider. It explains how to use the host to generate a model with the desired characteristics. For more information, refer to VOICE-INTELLIGENT-TECHNOLOGY.

Create the model

To create the model, perform the following steps:

Log in to the VIT website: VIT Model Generation Tool
Click the GENERATE MODEL tab.
Select SW platform & version as “Linux BSP” and “LF6.1.55_2.2.0”. Also, select the applicable options for Device as “i.MX93” and Language as “English”.

Add wakewords, which act as a trigger that tells VIT when to start listening for a voice command. When a new wakeword or command is created, it asks to set the value for “Sensitivity”. This parameter increases the recognition rate, which means if it is a positive value it is easier to detect but can result in more false detections. Instead of the negative value used to avoid confusion between keywords, maintain the sensitivity value as 0. For example, here, the phrase “hey led” is added.
Add the voice commands to be used and eliminate the ones not used.
Click the Generate model button and wait until the Download model button is unlocked.

The model is sent to the MY MODELS tab. To download the most recent model, click the download icon.
Extract the zip folder and save the file VIT_Model_en containing the VIT_package folder.

Compiling VIT voice_ui_app as standalone
Voice_ui_app is an example created for the repository imx-voiceui. This application uses the model to detect wakewords and commands. A utility used by this document is the “notify” argument. This argument when it detects a wakeword or command, opens a Python file WakeWordNotify or WWCommandNotify with a system argument using the identifier (ID). This ID helps to differentiate between the triggers.

To create the voice_ui_app on the host and help to assign it to the previous model created, perform the following steps:

Clone VIT repository including the branch version, using the following command:
$ git clone https://github.com/nxp-imx/imx-voiceui -b lf-6.1.55-2.2.0
Create a backup of the original file, using the following command:
$ cd <build-dir>/imx-voiceui
$ mv <Custom VIT_Model_en.h> ./vit/platforms/iMX9_CortexA55/lib/VIT_Model_en.h

Set up the toolchain previously installed:
$ source /opt/fsl-imx-xwayland/6.1-langdale/environment-setup-armv8a-poky-linux
Note: Use the toolchain created by Yocto.
Build your project, using the following command:
$ make all VERSION=04_08_01 CURRENT_GCC_VERSION=10 BUILD_ARCH=CortexA55
Once the project is built, it generates a directory named release. Copy the file voice_ui_app in this directory to the EVK:
$ scp release/voice_ui_app root@<evk ip>:/home/root

Using the parameter -notify
The script called by voice_ui_app when passing the “-notify” flag, must be in the path /usr/bin/. Use the attached files to /usr/bin/ and copy these scripts to the EVK.

$ scp WakeWordNotify root@<evk ip>:/usr/bin/
$ scp WWCommandNotify root@<evk ip>:/usr/bin/

The files inside, use the wakeword/command ID and send it through the message queue.
After copying these files to the EVK, use the parameter “-notify” to imply that the files WakeWordNotify, and WWCommandNotify, have the necessary permissions. To add it on the EVK, execute the following command:

root@imx93evk:~# chmod a+x /usr/bin/WakeWordNotify root@imx93evk:~# chmod a+x /usr/bin/WWCommandNotify

Audio front-end
The audio front-end (AFE) is used as a feed for VIT voice recognition. It helps to clean noise and echo by using the source and a reference of the speaker. Therefore, the result is a clear single channel microphone audio that can be used for processing. For more information, see VOICESEEKER.
AFE can be found inside the EVK at the path /unit_tests/nxp-afe.

To prepare and execute the program, follow the steps in file TODO.md in nxp-afe:

Ensure that the DTB is imx93-11×11-evk.dtb.
Install aloop module to support AFE:
root@imx93evk:~# sudo modprobe snd-aloop
Create a backup of asound.conf and use the corresponding asound.conf for the board:
root@imx93evk:~# mv /etc/asound.conf /etc/asound-o.conf
root@imx93evk:~# cp /unit_tests/nxp-afe/asound.conf_imx93 /etc/asound.conf

Change the WakeWordEnginge to use the VIT word engine correctly. This configuration is inside the file /unit_tests/nxp-afe/Config.ini.
Modify the property WakeWordEngine = VoiceSpot that uses VoiceSpot as a default to WakeWordEngine = VIT.
To test the AFE, execute voice_ui_app:
root@imx93evk:~# ./voice_ui_app &
Note: For this case, it is not necessary to add the parameter “-notify”.

Execute the AFE, using the following command:
root@imx93evk:~# /unit_tests/nxp-afe/afe libvoiceseekerlight &
To determine if AFE runs in the background, use the & command. To know what other programs are running in the background, use the following command:
root@imx93evk:~# ps
To close the AFE or voice_ui_app, use the following command:
root@imx93evk:~# pkill afe
root@imx93evk:~# pkill voice_ui_app

Running voice_ui_app without -notify

After following the steps in the TODO.md file, run the binary voice_ui_app from the terminal on the EVK. It displays information about how the VIT is running.
To feed the voice_ui_app, execute the AFE using the following command:
root@imx93evk:~# /unit_tests/nxp-afe/afe libvoiceseekerlight &

Say the wakeword and voice command and check if it is working as expected. It shows the wakeword and the voice command in the terminal as follows:
– Wakeword detected 1 HEY NXP StartOffset 16640
– Voice Command detected 3 TURN ON

GUI Guider VIT application

As explained earlier, the application/script command_handler through the VIT notification sends the command ID and wakeword ID to a message queue as IPC. It then captures these IDs to simulate an event in a GUI-Guider application. Figure 26 shows how this communication has been executed.

Note: Ensure to configure the handler to work correctly with the custom model created. These modifications must be applied on the host.

Use command_handler to simulate events

To use the command_handler to simulate events, perform the following steps:

Add the files command_handler.h and command_handler.c to the GUI Guider project in the directory /<GUI-Guider project path>/custom/.
To match the current model used, modify the command_handler.h by changing the voice_cmd_t and voice_ww_t.
Note: Ensure that the same order is used in the model.
Modify the quantity of wakewords and commands in the file /<GUI-Guider project path>/custom/command_handler.h:
#define VIT_WW_NUMBER 2
#define VIT_CMD_NUMBER 5

Initialize the command interface in the file /<GUI-Guider project path>/custom/custom.c. GUI Guider generates this file automatically.
#include “command_handler.h”
Function defined as void custom_init(lv_ui *ui) is available in the file /<GUI-Guider project
path>/custom/custom.c. This function can be modified to add a code and the initializer command start_command_handler() as follows:
void custom_init(lv_ui *ui)
{
/* Add your codes here */
start_command_handler();
}
Where:
The start_command_handler() is used for creating a thread running as a handler, taking messages sent by VIT, and executing commands assigned by command_handler_link().
To link the VIT wakewords and command with the object and event, use the following command:
void command_handler_link(voice_ww_t WW_Id, voice_cmd_t CMD, lv_obj_t** obj, lv_event_code_t event);
Where:
• The command_handler_link() is used to save an event to simulate for VIT execution.
• The inputs, voice_ww_t and voice_cmd_t, are created in step 2 relate directly with the VIT model.
• The third argument, lv_obj_t**, relates to GUI Guider object creation. First, locate the object to be linked. The name conforms with the next structure <screen located>_<name of the object>. To find where it is defined, check the file generated by GUI Guider at generated/gui_guider.h. Here, you can find the next structure with all the possible objects to link.

The function custom_init(lv_ui *ui) is used to initialize at the start of GUI Guider execution. This structure can be used to relate it with an object, knowing how to use it correctly. The pointer of the given structure is *ui, and the pointer to search is lv_obj_t**. Therefore, it is necessary to use this structure with the next format:

&ui->speed_btn_1

The fourth argument, lv_event_code_t event, relates to the event that is going to be triggered. It usually has a structure like this: LV_EVENT_<EVENT ASSIGNED>. It determines what to do with the triggered event through the code viewer in the file events_init.c.
For example, the btn_1 created in the screen speed have these events generated by GUI Guider.

Example
This section demonstrates an example of this implementation to add voice support to the GUI Guider, toggling the LED widget and changing between GUI screens.

Using the GUI template created with the button, add the widgets. For example, add an LED widget.
Add the event pressed to the btn_1 and to change the background add the configuration of the event. For this case, the background must be selected as black to “turn off” the LED widget. Therefore, the event used is pressed > led_1 > Background black (#000000).
Using the same button, configure an event to assign it to “turn on”. For this case, add the event released to the btn_1 and add red to the background. Therefore, the event used is released > led_1 > Background red (#ff0000).

Once the GUI is created, add command_handler.c and command_handler.h to the custom/folder.
To create the link between events and VIT, add the following lines in custom_init() inside the file in custom/custom.c. To change between screens, add two more events by linking btn_1 to change to screen 2.
Where:
- The wakeword HEY_LED and command TURN_OFF combination is assigned to turn off the LED. In other words, change the background to black.
- The wakeword HEY_LED and command TURN_ON combination is assigned to turn the LED red.
- The wakeword HEY_NXP and command NEXT combination is assigned to change between screens using the event assigned all to btn_1, and using btn_before in screen 2.
- The wakeword HEY_NXP and command RETURN combination is assigned to return to screen 1.

Select Project > Build > Yocto and build the project.
Sent the new binary to the EVK.
Note: The information log provides the binary location.
scp <binary location> root@<evk ip>:/home/root

Testing and configuration
Once the download has finished, perform the following steps on the EVK:

Verify that the snd-aloop module is already loaded by running lsmod. If the module is not found, load it using the following command:
root@imx93evk:~# sudo modprobe snd-aloop
Run voice_ui_app using the following command:
root@imx93evk:~# ./voice_ui_app -notify &
Where:
- The -notify is used to send a notification to WakeWordNtfy and WWCommandNtfy.
  Note: Remember to copy WakeWordNtfy and WWCommandNtfy to usr/bin.
- The & is used to run in the background.
Verify that the VIT engine is set on the Config.ini.
Run AFE with libvoiceseekerlight in the background:
root@imx93evk:~# cd /unit_tests/nxp-afe/
root@imx93evk:~# ./afe libvoiceseekerlight &
Open the GUI Guider application using the following command:
root@imx93evk:~# ./gui_guider
Until this step, the LVDS screen, or HDMI displays the GUI created.
Try using a previously assigned wakeword and voice command, for example, say “Hey NXP” and “Turn off”. After saying the command for power off, depending on the callback assigned, GUI Guider performs an action. For this example, GUI Guider changes the background color for the LED widget.

Related resources

Table 2 lists some additional resources used to supplement this document.

Table 2. Related resources

Resource	Link/how to obtain
i.MX 93 Applications Processor Family – Arm Cortex-A55, ML Acceleration, Power Efficient MPUNXP i.MX 93 A1 (i. MX93)	https://www.nxp.com/products/processors-and- microcontrollers/arm-processors/i-mx-applications- processors/i-mx-9-processors/i-mx-93-applications- processor-family-arm-cortex-a55-ml-acceleration-power- efficient-mpu:i.MX93
Embedded Linux for i.MX Applications Processors (IMXLINUX)	http://www.nxp.com/IMXLINUX
GUI Guider v1.6.1 User Guide (GUIGUIDERUG)	https://www.nxp.com/docs/en/user-guide/ GUIGUIDERUG-1.6.1.pdf
VIT i.MX voiceUI repository	https://github.com/nxp-imx/imx-voiceui

Note about the source code in the document

Example code shown in this document has the following copyright and BSD-3-Clause license:
Copyright 2023-2024 NXP Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials must be provided with the distribution.
Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Revision history
Table 3 summarizes the revisions to this document.

Document ID	Release date	Description
AN14270 v.1.0	16 May 2024	Initial public release

Legal information

Definitions
Draft — A draft status on a document indicates that the content is still under internal review and subject to formal approval, which may result in modifications or additions. NXP Semiconductors does not give any representations or warranties as to the accuracy or completeness of information included in a draft version of a document and shall have no liability for the consequences of use of such information.

Disclaimers
Limited warranty and liability — Information in this document is believed to be accurate and reliable. However, NXP Semiconductors does not give any representations or warranties, expressed or implied, as to the accuracy or completeness of such information and shall have no liability for the consequences of use of such information. NXP Semiconductors takes no responsibility for the content in this document if provided by an information source outside of NXP Semiconductors.
In no event shall NXP Semiconductors be liable for any indirect, incidental,punitive, special or consequential damages (including – without limitation – lost profits, lost savings, business interruption, costs related to the removal Mor replacement of any products or rework charges) whether or not such damages are based on tort (including negligence), warranty, breach of contract or any other legal theory.
Notwithstanding any damages that customer might incur for any reason whatsoever, NXP Semiconductors’ aggregate and cumulative liability towards customer for the products described herein shall be limited in accordance with the Terms and conditions of commercial sale of NXP Semiconductors.

Right to make changes — NXP Semiconductors reserves the right to make changes to information published in this document, including without limitation specifications and product descriptions, at any time and without notice. This document supersedes and replaces all information supplied prior to the publication hereof.
Suitability for use — NXP Semiconductors products are not designed,authorized or warranted to be suitable for use in life support, life-critical or safety-critical systems or equipment, nor in applications where failure or malfunction of an NXP Semiconductors product can reasonably be expected to result in personal injury, death or severe property or environmental damage. NXP Semiconductors and its suppliers accept no liability for inclusion and/or use of NXP Semiconductors products in such equipment or applications and therefore such inclusion and/or use is at the customer’s own risk.

Applications — Applications that are described herein for any of these products are for illustrative purposes only. NXP Semiconductors makes no representation or warranty that such applications will be suitable for the specified use without further testing or modification.

Customers are responsible for the design and operation of their applications and products using NXP Semiconductors products, and NXP Semiconductors accepts no liability for any assistance with applications or customer product design. It is customer’s sole responsibility to determine whether the NXP Semiconductors product is suitable and fit for the customer’s applications and products planned, as well as for the planned application and use of customer’s third party customer(s). Customers should provide appropriate design and operating safeguards to minimize the risks associated with their applications and products.

NXP Semiconductors does not accept any liability related to any default,damage, costs or problem which is based on any weakness or default in the customer’s applications or products, or the application or use by customer’s third party customer(s). Customer is responsible for doing all necessary testing for the customer’s applications and products using NXP Semiconductors products in order to avoid a default of the applications and the products or of the application or use by customer’s third party customer(s). NXP does not accept any liability in this respect.

Terms and conditions of commercial sale — NXP Semiconductors products are sold subject to the general terms and conditions of commercial sale, as published at https://www.nxp.com/profile/terms, unless otherwise agreed in a valid written individual agreement. In case an individual agreement is concluded only the terms and conditions of the respective agreement shall apply. NXP Semiconductors hereby expressly objects to applying the customer’s general terms and conditions with regard to the purchase of NXP Semiconductors products by customer.

Export control — This document as well as the item(s) described herein may be subject to export control regulations. Export might require a prior authorization from competent authorities.
Suitability for use in non-automotive qualified products — Unless this document expressly states that this specific NXP Semiconductors product is automotive qualified, the product is not suitable for automotive use. It is neither qualified nor tested in accordance with automotive testing or application requirements. NXP Semiconductors accepts no liability for inclusion and/or use of non-automotive qualified products in automotive equipment or applications.

In the event that customer uses the product for design-in and use in automotive applications to automotive specifications and standards,customer (a) shall use the product without NXP Semiconductors’ warranty of the product for such automotive applications, use and specifications, and (b) whenever customer uses the product for automotive applications beyond NXP Semiconductors’ specifications such use shall be solely at customer’s own risk, and (c) customer fully indemnifies NXP Semiconductors for any liability, damages or failed product claims resulting from customer design and use of the product for automotive applications beyond NXP Semiconductors’ standard warranty and NXP Semiconductors’ product specifications.

Translations — A non-English (translated) version of a document, including the legal information in that document, is for reference only. The English version shall prevail in case of any discrepancy between the translated and English versions.

Security — Customer understands that all NXP products may be subject to unidentified vulnerabilities or may support established security standards or specifications with known limitations. Customer is responsible for the design and operation of its applications and products throughout their lifecycles to reduce the effect of these vulnerabilities on customer’s applications and products. Customer’s responsibility also extends to other open and/or proprietary technologies supported by NXP products for use in customer’s applications. NXP accepts no liability for any vulnerability. Customer should Mregularly check security updates from NXP and follow up appropriately.
Customer shall select products with security features that best meet rules, regulations, and standards of the intended application and make the ultimate design decisions regarding its products and is solely responsible for compliance with all legal, regulatory, and security related requirements concerning its products, regardless of any information or support that may be provided by NXP.

NXP has a Product Security Incident Response Team (PSIRT) (reachable at PSIRT@nxp.com) that manages the investigation, reporting, and solution release to security vulnerabilities of NXP products.
NXP B.V. — NXP B.V. is not an operating company and it does not distribute or sell products.

Trademarks

Notice: All referenced brands, product names, service names, and trademarks are the property of their respective owners.

NXP — wordmark and logo are trademarks of NXP B.V.
i.MX — is a trademark of NXP B.V.

Please be aware that important notices concerning this document and the product(s) described herein, have been included in section ‘Legal information’.
© 2024 NXP B.V. All rights reserved.
For more information, please visit: https://www.nxp.com

Date of release: 16 May 2024
Document identifier: AN14270

Documents / Resources

NXP AN14270 Adding Voice Support to GUI Guider [pdf] User Guide
AN14270 Adding Voice Support to GUI Guider, AN14270, Adding Voice Support to GUI Guider, to GUI Guider, GUI Guider, Guider

References

User Manual

NXP AN14270 Adding Voice Support to GUI Guider

Product Usage Instructions

Introduction

Overview

Hardware, software, and host requirements

Pre-requirements

GUI Guider

VIT

GUI Guider VIT application

Related resources

Legal information

Documents / Resources

References

Leave a comment

Cancel reply