Please refer to the NXP.com landing page https://www.nxp.com/navqplus for NavQPlus for availability, pricing, availability and distribution channels.

NavQPlus Part numbers

PLEASE NOTE: There are currently TWO variants of the NavQPlus available the part numbers start with 8MPNAVQ:

• 8MPNAVQ-8GB-XG This variant does not include the IX Industrial gigabit ethernet Connector and PHY on board. All other components are installed including 100BaseT1 and WiFi. Ethernet over USB-C "gadget mode" is also available.

• 8MPNAVQ-8GB-G This variant includes the IX industrial connector and Gigabit Ethernet PHY

Presently the following third party companies are able to provide commercial support for NavQPlus, including software support, prototyping derivatives, and/or volume manufacturing of the SoM or carrier board. Please contact the NXP Mobile Robotics team if you have a variant that you would like to let people know about:

Introduction

The 8MPNAVQ or "NavQPlus" is a small purpose-built Linux computer evaluation kit (EVK) based on the NXP i.MX 8M Plus SoC. It is focused on the common needs of mobile robotics systems, with a small form factor, Dronecode-compliant JST-GH connectors, and available software stack including Ubuntu Linux and ROS2.

The entire design is available for companies building their own similar hardware. NavQPlus is built as a stack of boards, the top board being a SoM (System-on-Module) containing the processor, memory and other components with strict layout requirements, and where the secondary boards are relatively inexpensive (often 4 layer boards) and allows for versions with customization to be easily built.

Note that the SoM is almost identical to the larger NXP EVK for i.MX8M Plus with the exception of the I/O voltage level being changed to 3.3V. This makes NavQPlus an excellent stepping stone or bridge from the large EVK to a system that can be duplicated for testing in situ, or even copied directly for your application.

1. NXP i.MX 8M Plus SoC on a SoM with LPDDR4 DRAM and eMMC flash.

   • 4x Arm Cortex-A53 core

   • 1x Arm Cortex-M7 core

The NavQPlus is suitable for many purposes, including generic robots, various vision systems, and AI/ML applications.

• Unmanned Aerial Vehicles (UAVs)

  • Such as multicopters and VTOL (Vertical Take-off and Landing) aircraft

• Rovers and other unmanned ground vehicles (UGVs)

Two specific complete developer tool examples are the , and the .

The intent of the 8MPNavQ in HoverGames is to enable participants with a solution that allows them to harness common robotics packages and libraries such as:

• ROS/ROS2

• OpenCV

• GStreamer

The 8MPNavQ runs Linux with a package manager, so you should be able to install the packages that you need to complete your projects successfully and efficiently.

Introduction

This chapter will cover the basics of connecting to the NavQPlus.

For a quick setup guide follow the instruction on the previous chapter. For more detailed information follow the hardware reference section.

Following these 8 steps, you will be able to start using the NavQPlus in no time. When needed, more information is available in the detailed instructions chapter. Also checkout the TurtleBot4 / iRobot Create3 documentation, and the other parts of this GitBook.

1. Download an Ubuntu image

Download the latest Ubuntu image for NavQPlus (in .wic file format) from GitHub:

• For use with iRobot Create3 (AKA Turtlebot4)

• For use with NXP MR-B3RB

uuu is an NXP command line tool that runs on a PC and can commnicate directly with the MPU on the NavQPlus. To flash the eMMC memory on your NavQPlus (next step), you will also need to download the uuu tool ("Universal Update Utility"). Download the latest release from GitHub:

Make sure to download the correct application for your platform. The .exe file is a Windows executable. The file named "uuu" without extension is a x86/64 Linux binary.

Before plugging in the board, find the  on your NavQPlus and flip them to the "flash" mode. See the table and picture below for reference.

The NavQPlus firmware is preferably installed on eMMC memory for reliability reasons, even though it may be convenient during development to use the SD card. Especially if you are flying a drone, vibrations may cause (occassional) failure of the physical connections to an SD card.

Connect the NavQPlus to your computer using the leftmost USB-C port (USB 1). The two status LEDs should light up as shown above.

Open a command line window. Run the following command to check that the NavQPlus is recognized by UUU:

You should see that there is a device detected. To flash your board, use the command below (adapt the filename/version to match the image file that you downloaded in step 1):

Once this process has finished, make sure that the flash process was successful by comparing the program output to the image below.

You should now (again) change the  to boot from eMMC (also see step 3).

Power on the NavQPlus by plugging in a USB-C cable to the centermost USB-C port (USB2). Make sure to provide enough power (a >5W supply is recommended). The NavQPlus will boot, and you will be able to confirm it has fully booted by observing the LEDs on board. The three LEDs by the USB1 port should all be on, as well as two LEDs next to the CAN bus connectors.

To log into NavQPlus for the first time, you can either use the included USB to UART adapter, ethernet, or USB gadget mode.

Connect the included USB to UART adapter to the UART2 port on the NavQPlus, and open your favorite serial console application (e.g. PuTTy for Windows users, Minicom on Linux). Open a serial console and set the baud rate to 115200. If there is no output on the screen, try to press enter to get a log-in prompt.

If the boot was successful, in the terminal it will ask for the username and then the password. The default username/password is as follows:

At this point you can start playing around already with the NavQPlus. However, it is recommended to also follow the last steps.

To connect to the board over ethernet, connect the included ix Industrial ethernet cable to NavQPlus, and connect the RJ45 connector to your computer, switch, or router on your local network. You can log into NavQPlus over SSH. More information on this setup is explained in the . The default hostname for NavQPlus is imx8mpnavq or use the IP adress from your board instead. To SSH into NavQPlus, you can run the following command:

It will also ask the password after a successful connection to your board. As mentioned above the default password is user.

The IP address of the usb0 network interface on NavQPlus is statically assigned to 192.168.186.3. If you want to use USB gadget ethernet to connect to NavQPlus, you will need to assign a static IP to your existing gadget ethernet interface on your computer.

First go to your network settings and click on the plus icon on the top right.

The network configuration is as follows:

IP Address: 192.168.186.2

Network Mask: 255.255.255.0

Once you have set up your USB-C gadget ethernet interface on your computer, you can SSH by running:

The flashed images MAY need expanding to utilize all the available storage. After logging into the NavQPlus, open a terminal and run:

• Expand image on the eMMC memory (if you followed the instructions above):

• Expand image on the SD card (if you chose to flash the image on the SD card):

To change the default username and password, use the commands below.

Username (replace <new_username> with your desired username):

Password (you will be prompted to enter the current and new password):

Now with the NavQPlus setup complete, you can start to install other software packages and run your own code. For example, (Robot Operating System) is commonly used as a framework for controlling robotic systems, with plenty of compatible packages being available.

There are two ways to power the NavQPlus. You can power it through the PWR IN port or through the middle* USB-C port (*dependent on software image loaded)

This is because it is possible that the USB-C power management logic may be configured in software in a manner that limits current or resets the power management in the time between the bootloader running and the Linux image running . This leads to unexpected behavior at power up. If you suspect something unusual is occurring on power up or you see the board rebooting, please try powering through PWR_IN first.

The PWR IN port accepts an input in the 5V-20V* range. (Technically higher (24V?), but has not been fully validated or characterized)

The NavQPlus may be considered a generic embedded Linux Computer. When running Ubuntu POC, most linux packages may be installed using apt or apt-get. As with any Linux machine not all packages are suited to the specific hardware.

There is also specific emablement related to the i.MX 8M Plus SOC chip that is used. Please refer to NXP.com for more details. This includes things like hardware acclerated video using gstreamer and hardware accelerated neural net processing using eIQ on the NPU module. Note that the will demonstrate the usage of NavQPlus as a Robotic platform running ROS and is considered one of our reference development tools. Following the software guides there may be preferable, and provide more detail.

This image uses Netplan to configure the network manager which is "Networkmanager".

Setting the IP address using ifconfig will NOT be applied persistently, and can/will be overridden periodically by Networkmanager This manages network conflicts for controlling IP networks like Ethernet and WiFi. Network Manger has several command line utilities

• nmcli to get current network status

• nmui is a termnial user interface to modify connections

  • set static IP/ DHCP

  • set DNS

  • connect to a wifi network

Examples are provided in the and sections.

You can follow this tutorial below in order to set Static IP with NavQ+ :

You may wish or need to modify your NavQPlus to accept additional camera types. This is not difficult, but does require care.

The Production "RevB version" of the NavQPlus makes a small adjustment to the MIPI CSI Clock line in order to be more compatible with a variety of image sensors. This is also the configuration used with the OV5645 fixed focus image sensors from Innowave that ship with the RevB board As shown in the image below, the resistors R21 and R37 shoudl be 0 Ohm (or solder jumpers) and the resistors R22 and R38 should be removed. (DNP/DNI).

There are multiple UARTS on NavQPlus.

Because of pinmuxing these can sometimes be assigned to different uses and locations depending on the specifics of the Linux BSP and DTB files. The default configuration for NavQPlus LInux image provided at time of publication will be described here. Please double check any notes on your specific Linux Image if something varies from this configuration.

Accessing the external I2C bus

The i.mx 8M Plus has a number of I2C busses on board. Internally they are connected to a variety of onboard peripherals. Normally you will not need to address these peripherals directly, and they will be handled by Linux drivers.

• I2C1 - SOM only for PMIC control

• I2C2 - MIPI CSI1, LVDS1, DSI

• I2C3 - MIPI CS2, LVDS2, PCIe

• I2C4 - USB1 TCPC, USB2 TCPC, Secure Element, RTC

  • TCPC1 I2C ADDR: 1010001X

  • TCPC2 I2C ADDR: 1010010X

AUX connector: I2C bus #6 is pin-muxed with UART4 to the six pin JST-GH J12 connector and is the external I2C bus is enabled on the AUX port of the NavQ+. By default these are configured for I2C and not UART4 (internal MCU)

A table of the J12 pinout is below. Note that pin 1 is on the left side of the connector:

You only need to use pins 1, 2, 3, and 6 for I2C. These GPIO are 3.3 volt tolerant only.

To detect that a device is present on the bus, you can run the following command:

You may need to add the 'user' user to the i2c group to access the bus. To do this, run the following command, then log out and log back in:

The SE050 or SE05x secure element will not respond to an i2cdetect command. "Plug and Trust" software library should be used to interface with the external Secure Element.

Introduction

UART3 is available for general use. Hardware flow control is supported.

Note from the schematic clip below, that the MPU can multiplex these signals with SPI1. This is normally configured in the Linux image and is not the default configuration.

UART3 Interface voltage

The signaling from the SOM to the NavQPlus carrier board on J9 is at 3V3 but the Murata 1ZM expects 1.8V. The level conversion is done using U26.

UART3 Locator

Schematic

All the UART signals are protected from ESD using the Nexperia IP4292CZ components. This is part of an optimized BOM as they are also required for the USB interfaces. In additional to its exceptional performance the board layout may be optimized because of being able to route traces straight under the component.

UART3 may be accessed as a standard /dev/ttyS_ in Linux. UART3 may be accessed /dav/ttymxc2 in linux <TODO-check wich ttyS number it is>

Connecting the Innowave OV5645 Camera

<todo> add more detail

The innowave camera comes pre-installed with the latest revision (2024) of the NavQPlus. It is a fixed focus camera unlike the autofocus google coral camera. The installation and removal is very similar to the the instructions below for the Google coral camera.

The flex cable has marking on it "this side up" that should be visible when looking at the connector side of the board. i.e you can read "this side up" and also read the silkscreen "CSI 1"on the bottom of the board at the same time.

Connecting the Google Coral Camera

Pin 1 (P1) on the Google Coral Camera should be connected to the pin with the arrow on the MIPI-CSI port. Please see the images below. The sides with the red box should line up. You should see the blue on the flex cable when connecting to the MIPI-CSI port.

Camera Mount

Depending on your kit, there may be a tall or short camera mount included. The short version typically ships with the NavQPlus or drone itself, while a tall version may come with an MR-Buggy3 development kit. Please refer to the image below for information on how to assemble.

The camera mount is provided unassembled.

PCIe signals are on a flex cable connection located on the back of NavQPlus. A PCIe adapter has been prepared by a 3rd party to work with NavQPlus. It is not in production as of yet. Please contact hovergames@nxp.com for more details.

There are several ports which may have or may be configured for GPIO connection. In addition there are several SMT pads designed to allow access to GPIO and signals such as the PMIC controls. Refer to the schematics for details.

<<TODO - add more detail here, and pictures of the schematics. Add an example pin access if available>>

UART4 interface voltage

The signaling from the SOM to the NavQPlus carrier board on J11 is at 3V3

Alternative output is on the AUX connector at location J12 also at 3V3 signalling. However this is not the default linux BSP, and would require changes to the dtb files.

Schematic

Note that J11/UART4 is the default location for UART4 signals. Also by default UART4 is assigned to the M7 Core on the i.MX8M Plus. An RTOS such as FreeRTOS or Zephyr would normally use it as the default console to the embedded MCU. You may note that the signal names are differed on J11 vs J12. This is only a labelling detail, since the pinmuxing on the chip is used to "move" the UART4 interface from one set of pins on the MPU (and board to board header). In order to route these signals independently on the carrier board, they need their own net names.

All the UART signals are protected from ESD using the Nexperia IP4292CZ components. This is part of an optimized BOM as they are also required for the USB interfaces. In additional to its exceptional performance the board layout may be optimized because of being able to route traces straight under the component.

Introduction

An RC remote control can be made to connect directly to the NavQPlus in order to transmit joystick and switch settings information. This can be then used in other software (ROS2) as input to control aspects of a vehicle directly or indirectly, such as reading an RC channel as an "arming switch". Note that this method uses a USB-UART adapter to facilitate the connection, but technically it is possible to create a direct serial connection.

Requirements:

• FlySky FS-i6S RC transmitter

• FS-i6B receiver

• NavQPlus baseboard with Ubuntu image release 22.04.3 or above

• FTDI type USB-UART cable/adapter

Connect the FS-i6B receiver to NavQPlus using TTL-UART cable (you need to prepare this cable yourself).

Connect the cable to a general use UART connector (the board is equipped with 4 connectors, three of them are available for general use. (Note UART1 is assigned internally to communicate with the Bluetooth portion of the WiFi/BT Wireless module on the NavQPlus Baseboard). Check this for more details.

Connect the three TTL wires Black/Red/White to the FS-i6B receiver as depicted in the picture below:

After plugging the receiver to NavQPlus board, you should see a red LED blinking in the receiver. If your transmitter is already on, it should bind automatically to the receiver otherwise you can bind it manually under its system menu. After binding, the red LED should be constantly glowing.

Under NavQPlus linux console, run the following command in the background in order to create a new joystick input device:

Now your receiver is attached, you can use it for your need (ROS, software simulation, ...)

In order to check it is detected properly, run jstest-gtk software.

The new controller should show up as "FS-iA6B iBus RC receiver". The bar graphs should change accordingly when you move the control sticks.

A Micro-HDMI interface is provided on the NavQPlus. This may be used to drive typical monitors or small LCD displays. Note only typical display timing and resolution is enabled/supported by default. A standard micro-HDMI cable may be used to connect to a typical monitor, or HDMI embedded displays.

HowTo: Remove unattended upgrades

apt remove unattended-upgrades

HowTo: Install nano

GNU nano is an easy to use command line text editor for Unix and Linux operating systems. It includes all the basic functionality you’d expect from a regular text editor, like syntax highlighting, multiple buffers, search and replace with regular expression support, spellchecking, UTF-8 encoding, and more.

Note: There are other text editors that can be used, Nano is a popular one. Some of the HowTo below will use Nano as the editor.

To install:

sudo apt install nano

HowTo: Edit hostname

Run the following command to change your hostname. Assuming you want to use the hostname "compcom42".

sudo nano /etc/hostname compcom42 

Change the hostname in hosts file

sudo nano /etc/hosts 

… 
127.0.1.1 compcom42 

Add the additional entries 



192.168.42.11   compcom<id> 
192.168.42.5    navq<id>-d2x 
192.168.42.2    t1eth8 
192.168.42.6    d2xmodem 
192.168.42.21   radar1 
192.168.42.22   radar2 
192.168.42.23   radar3 

HowTo: Set static ip configuration

Network manager is used for network config. See steps below

Determine the interface to be used

nmcli con show 

From <https://askubuntu.com/questions/246077/how-to-setup-a-static-ip-for-network-manager-in-virtual-box-on-ubuntu-server>

Set static ip

Wired connection 2 = 1000base-TX / eth1 Wired connection 1 = 100base-T1 / eth0

From <>

ROS is already installed on the 

See

See

We welcome user submitted 3d printer files for use with NavQPlus and NXPHoverGames, NXPRoverGames, NXP-CUP or other. Note you may also find 3D printer files in other NXP Gitbooks, and by searching Thingiverse or other 3d printer file repositories with some of the name above.

In addtion on the following pages there are also direct links to Fusion360 files used with NavQPlus, HoverGames drone, and MR-Buggy3

Misc YouTube links that may be relevant to NavQPlus.

<TODO> Check links

MAYBE LINKS:

Simulating Robots with Gazebo and ROS | Getting Ready to Build Robots with ROS

https://www.youtube.com/watch?v=laWn7_cj434

Here are some tips an tricks related to the desktop/laptop linux host computer that you may use to connect to your NavQPlus.

Ubuntu HOST laptop cannot screens share in MS Teams

Reported June 2023 - IAFG We often communicate, and have debug sessions using Microsoft Teams, (or Zoom). During a session on Teams it is helpful to share the screen of the Ubuntu Host.

Current Ubuntu distributions (22.04) may only enable Wayland graphics by default. However X is required in order for screensharing to work with TEAMs and ZOOM (possibly others).

Depending on your LInux distribution you may be able to switch to X simply by logging out. Use the small gear icon in the lower right of the screen to then select Ubuntu using X.

Follow this guide to enabling X on Ubuntu Linux to allow screen sharing: https://askubuntu.com/questions/1405195/how-to-share-a-screen-in-ms-teams-or-zoom-from-ubuntu-22-04

Below is a copy of the instructions given in the link:

To disable Wayland and use xorg only:

1. Open your terminal and write sudoedit /etc/gdm3/custom.conf

2. Uncomment the value waylandEnabled=false -- just remove the #

Introduction

Setting up the MicroDDS Agent/MicroROS

One method used to communicate between the NavQPlus and the FMUK66v3 using T1 or Serial is by using MicroROS or the XRCE-dds Agent. To install these tools:

git clone https://github.com/eProsima/Micro-XRCE-DDS-Agent
cd Micro-XRCE-DDS-Agent
mkdir build && cd build
cmake ..
make
sudo make install

If using yocto, you can use the WIP meta package in your recipe.

https://github.com/dirksavage88/meta-dds

Alternatively, you can install micro-ROS through the ubuntu snap store

Another way to get micro-ROS is through Github as a ROS2 package. You can use the colcon build tools after sourcing the ROS setup.bash script in "/opt/ros/galactic/setup.bash"

colcon build --symlink-install

Follow the instructions for each package on how to run the agent. The agent is a broker for clients on the network (including the FMUK66) and allows topics from the pixhawk to be shared with the DDS global space.

To set up the NavQ+, follow instructions in the Setup Guide -eMMC for a static IP. The FMUK66 is IP "10.0.0.1". As an example, you can set the NavQ+ to "10.0.0.3" with a blank ipv4.gateway (no quotes or anything) on Wired Connection 1.

Then start the microdds agent that is installed in the home directory in the Micro-XRCE-DDS-Agent build folder.

On the FMUK66, ensure you have flashed to main and enter the following command.

You should see the topic listed in the mavlink console after running the client start, as well as topic, publishers, data writers, and creators on the agent side.

Installing ROS2 on the NavQPlus

We have prepared an install script that will install ROS2 and all necessary packages on the NavQPlus.

To get the install script and run it, you can run the following in the terminal:

wget https://raw.githubusercontent.com/rudislabs/nxp_install/main/install.sh
chmod +x install.sh
./install.sh

Inference examples

The i.MX 8M Plus SOC in the NavQPlus contains a Neural Processing Unit (NPU) that can accelerate inference on the edge. There are some inference examples built into the NavQPlus image that will do image classification with the COCO dataset.

There is a TensorFlow Lite example in the /usr/bin/tensorflow-lite-2.6.0/examples/ folder. This example runs a mobilenet_v1 quantized image classification model. To run it, try the command below:

USE_GPU_INFERENCE=0 ./label_image --external_delegate_path=/lib/libvx_delegate.so -m mobilenet_v1_1.0_224_quant.tflite -i grace_hopper.bmp -l labels.txt

USE_GPU_INFERENCE=0 specifies that we want to run inference on the NPU. Removing this environment variable will run inference on the GPU.

To run inference on the GPU/NPU, you will need to use the libVX delegate, at the path /lib/libvx_delegate.so.

There is also a python script named label_image.py that contains example code for inference with TFLite.

Introduction

This page will go through a simple example using ROS on the NavQPlus. More examples and details can be found on the ROS webpage linked bellow. This example is a shortened version of the Publisher Subscriber for Python tutorial. You will need to have ROS2 installed already before trying this example.

ROS2 Publisher Subscriber in Python example

In this tutorial, you will create nodes that pass information in the form of string messages to each other over a topic. The example used here is a simple “talker” and “listener” system; one node publishes data and the other subscribes to the topic so it can receive that data.

Step 1 - Create workspace

First step is to make a workspace for your project to build in. Go to your home folder and create a workspace called /ros2_ws. With another directory inside /src for your project to be in.

mkdir -p ~/ros2_ws/src

Then move into the /src directory:

Now we want to create a package inside the directory we just created.

Your terminal will return a message verifying the creation of your package py_pubsub and all its necessary files and folders.

Navigate to the new directory location created.

Now download the example publisher code:

You should now see a new file located in the py_pubsub directory. To understand more about the code, follow the tutorial through the .

For the subscriber code stay in the same directory and download the following:

With this done you will have both publisher_member_function.py and subscriber_member_function.py files in your directory. Plus, the __init__.py.

The next step is to modify some of the files created to support the code we just downloaded. We will be adding the dependencies. Navigate one level back to ~/ros2_ws/src/pubsub.

Open the package.xml file with a text editor. We will be using nano for this tutorial.

After the <license> line add the following lines of code:

Your new file now should look something similar to this:

Exit the file editor and save.

The next file you will have to modify is the setup.py file.

Add the following line within the console_scripts brackets of the entry_points field:

Don't forget to save!

First, go back to the root of your workspace:

Then, check if you have any missing dependencies in your code by running:

If everything is installed successfully you can build your package with colcon:

With the build finished we need to source the setup files.

Finally, we can run the code. You will need two terminals to run both the publisher and subscriber.

In one terminal run the publisher:

You should see that the code starts running and prints:

On the other terminal run the subscriber:

When you run the listener, you will start to see the message from the publisher:

Use Ctlr + C in each terminal to stop the code.

You created two nodes to publish and subscribe to data over a topic. Before running them, you added their dependencies and entry points to the package configuration files.

Refer to nxp.com/navqplus order page for the exact details on what is included in the NavQPlus version that you have ordered.

The exact contents is based on the version kit ordered, Typically the following items are included:

• 8M Plus SOM + Baseboard, flat heatsink, 3d printed enclosure

  • Wifi Antenna attached

• Communications cables

  • FTDI USB-UART Serial console cable and adapter board/Cable

  • IX-industrial to RJ45 Ethernet cable (not on -XG version)

  • 2-Pin JST-GH Cable for two wire 100BaseT1 automotive ethernet
• Power Cables

  • 5-Pin JST-GH power cale to RED SYP type cable

  • RED SYP type cable to XT-60 battery connector

• Camera

  • Omnivision OV5645 on innowave module. (typical)

  • Several cameras are available to connect to the MIPI CSI interface.

Refer to the HoverGames disclaimer below when using NavQPlus with a drone or similar vehicle.

It is expected as a user of NavQPlus, you will have basic knowledge of how to operate an embedded Linux computer in a headless terminal environment. While NavQPlus can support a desktop environment, it is not a "PC" or desktop computer, and therefore many graphical applications designed for these devices will not work due to device specific libraries and graphics drivers.

If you are not comfortable operating a Linux computer in a terminal environment, below are links to some resources that may help.

The NavQPlus_MR-Buggy3 demo is a demonstration of the capabilities of the NavQPlus, the MR-Buggy3 platform, and NXP's CAN Bus hardware and software support for ROS2.

This guide will walk you through setting up the MR-Buggy3 demo on both your laptop and the NavQPlus. This demo consists of:

1. A Gazebo Ignition simulation environment with the MR-Buggy3 model running

2. Connection to the actual Buggy3 hardware meaning HITL (hardware in the loop) control of the real life MR-Buggy3

Introduction

General specifications have been requested for NavQPlus. Currently there are no official qualified specifications.

Physical Hardware

The CAD model below and associated measuring tools can be used to determine physical characteristics of interest. The model may also be downloaded in a variety of file formats by following the link to open in Fusion360.

Electrical Specifcations

PLEASE NOTE: These are unofficial specifications only. The values below may be used for guidance, but are not guaranteed.

Voltage input

• 5-20V

• Power supplied via High voltage USB PD power switch(es)

  • Power input and can be from dedicated connector or through USB-C

• A detailed power analysis has not been done. Below are estimates

  • Expectation is MAX 5W and typical 3W

  • 5W =~12V@450mA

• CAD files available for board outline and case though the

• 90mmx70mm exclusive of case mounting tabs

• Tabs 82mm at max width.

• 98.4grams with Fin type heatsink attached*

  • * production units use a flat aluminum plate which reduce weight further

• Contains Transmitter Module FCC ID: VPYLB1ZM or Contains FCC ID: VPYLB1ZM

• FCC CAUTION: Changes or modifications not expressly approved by the party responsible for compliance could void the user’s authority to operate the equipment.

• This transmitter must not be co-located or operated in conjunction with any other antenna or transmitter.

NavQPlus is a standalone embedded linux device. There are many peripherals that will attach and interface with it, or can be made to interface with the correct drivers. In addition, the Mobile Robotics team works with several complimentary devices and boards which work with the NavQPlus:

• MR-B3RB (Buggy3 RevB): a robotics platform in the form of an ackermann steering small car

• iRobot Create3: AKA Turtlebot 4, ROS development platform

BSD-3 License

Example code shown in this document has the following copyright and BSD-3-Clause license:

Copyright 2023 NXP. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. 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.

3. 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.

The NavQPlus is an embedded Linux device. You will need terminal access via a PC or Laptop in order to interface with the board. While a Windows PC can have terminal programs, you will find that working in a Linux host environment will allow you greater flexibility, capability and being able to cross compile software more easily. Most examples will be shown assuming a linux host PC running Ubuntu 22.04 or later is attached.

Learn about installing Ubuntu Desktop on a development PC using the link below:

The software available for the NavQPlus includes an Ubuntu Desktop environment based on Ubuntu opensource distribution as a Proof of Concept (PoC). It should be clearly noted that this Ubuntu PoC is NOT an official Canonical distribution.

Canonical outlines this mission philosophy of supporting free and opens software here:

Canonical does independently support commercial development on NXP i.MX processors and they are available on a contractual basis to provide commercial support for Canonical Ubuntu on NXP processors.

The NavQPlus was prepared in cooperation with one of our Gold partners Emcraft. It should be noted that various NXP partner program partners are available for commercial support including hardware and software support. Please refer to the NXP partner program webpages for further details:

This tutorial describes how to operate with using and .

The packages from are built on NavQPlus which will read input from the Joystick and send the appropriate commands to FMURT6 over ethernet.

The application in running on FMURT6 takes commands from NavQPlus and sends operation signals to MR-Buggy 3 servo and motor controller.

This tutorial demonstrates how to write text on OLED display modules using the I2C interface of board.

This tutorial explains how to operate APA102 LED Board via NavQPlus with ROS2 over UCANS32K1 Board. NavQPlus and UCANS32K1 boards will communicate via CAN-FD. UCANS32K1 and APA102 boards will communicate via SPI.

• NavQPlus Board

• USB-UART serial debugger cable

NavQPlus is an open design and 3rd parties may create add-on modules

Contact the vendors below for more details:

Emcraft:

• TOF camera from PMD

• Several RPI camera modules

• mini PCIe adapter

Google

• Coral Cam

• Coral TPU Neural net accelerator

NavQPlus Enablement

NavQPlus has specific enablement that is not typically found in generic EVK's from NXP. The Ubuntu POC , ROS2 and other software has been enabled in order to work with robotics development systems. Consider using the a pre-built binary or following the 3rd party reference on building from source using a Docker image.

Opensource Community

While our team may have used and tested this software, the enablement is under continual development and is expected to change regularly. Where this software is application level (I.e ROS2), and not hardware device level (i.e gstreamer) you should look for opensource ommunity support for that application and not directly from NXP

Guidance

Elsewhere in this "engineering notebook" GitBook you will find specific guidance on how some of this software may be used. Specific software used in these examples will be noted.

OS/Software

Example NavQPlus typical OS images may include the following. (note that this configuration changes regularly and may be updated/upgraded to newer versions.)

• NXP Yocto Linux 5.15 kernel

  • gstreamer

  • eIQ AI/ML tools

  • Ethernet over USB-C Gadget mode (SSH connection to laptop using USB cable)

• Ubuntu 22.04 built on top of NXP Yocto 5.15

  • ROS2 Humble enabled

NXP i.MX 8M Plus Linux is a Yocto build plus Desktop image layer. Refer to the NXP GIT repo and NXP documentation when building from source.

NavQPlus is a derivative of the NXP EVK. Refer to the NXP website for the complete variety of software support for i.MX 8M Plus

For a complete view of all the software available for i.MX 8M Plus please refer to the NXP website here:

Because NavQPlus is experimental and contains a new set of boards and peripherals, please expect and plan for software enablement to undergo several iterations. Our intent is to provide an Ubuntu PoC (Proof of Concept) "user-friendly Linux" with typical packages and additional tools included, rather than the traditional Yocto-based distribution that is typical of the highly optimized and stripped down Linux operating systems used in deeply embedded products. Since this Ubuntu PoC is also built on top of Yocto, it is still able to be reduced and optimized for full commercial deployment as well.

Building the Linux image from source is complex and time consuming. A 3rd party has prepared a docker image which can be used and instructions to be followed in order to be successful in building from source without being an Expert. Please follow this guide in order to build the latest image from source, in a docker window. https://github.com/rudislabs/navqplus-images?tab=readme-ov-file#build-steps-for-current-image-release

NavQPlus models typically ship with one Omnivision camera module which is either from Innowave or Google Coral Camera. 3rd parties may also have other cameras. An additional camera can also be added to the second MIPI port. Note that other USB or Ethernet cameras can also supply image data to the NavQPlus. Please refer to NXP.com documentation for i.MX 8M Plus for details on camera usage in LInux.

Video example using gstreamer

To take an image using an attached MIPI camera module on NavQPlus, use the gstreamer command. An example command is as follows:

sudo gst-launch-1.0 -v v4l2src device=/dev/video3 num-buffers=1 ! jpegenc ! filesink location=capture1.jpeg

The NavQPlus has the ability to connect via ethernet in several different ways.

• Through the IX Industrial® Type A port. The provided IX to RJ45 adapter cable will allow connecting to RJ45 *Preferred

• Using the USB-C port with "gadget bode" Ethernet over USB

NavQPlus should boot normally after applying power. While booting, the device will output detailed status information to the serial console, accessible on the . Using the console can provide invaluable debugging information that is difficult to find elsewhere. Once the boot process has completed, the system console is also available by starting an SSH session over (USB-)ethernet or Wi-Fi.

If the applied voltage at PWR_IN is too low, the boot process could hang upon initializing the CPU in the Linux kernel. Please make sure that your power input is 5-20V. The NavQPlus has relatively low current requirements and typically will not draw more than 4 watts of power when all on-chip peripherals are enabled, however the board may also supply power to external devices. Ensure that your power source is able to maintain a stable voltage level at the requested current.

The boot process starts with U-Boot, loading the device trees in the boot partition and loading the Linux kernel. If you desire to observe the complete boot process, you will need to monitor the output on by using the provided USB to serial converter cable.

Once the NavQPlus has booted to the shell, the default login credentials are as follows:

Configuring WiFi, System Hostname, Username or Password

Configuring WiFi on NavQPlus

To connect NavQPlus to a WiFi network, use the nmcli command. The interface is relatively straightforward, to connect with nmcli, run the following command:

sudo nmcli device wifi connect <network_name> password "<password>"

If struggling to connect to a network, see if it is visible by running:

sudo nmcli device wifi list

Once connected to the WiFi network the NavQPlus will continue to connect to that network even after a reboot.

About nmcli

The netowork connections will be saved and NavQPlus will automotically connect to these networks when they are present. Note that the priority of connections can be set as well as removing connections. For more information see the nmcli linux command. https://manpages.ubuntu.com/manpages/noble/en/man1/nmcli.1.html

To see what Wifi network the NavQPlus is currently connected to run without sudo:

nmcli device wifi list

Or if running with sudo it will be the network preceeded with a star.

Once setup to connect over a local WiFi network, SSH into the NavQPlus over WiFi by running:

Or depending on network setup:

Introduction

When new images are released, we will provide a link to them. To flash NavQPlus, normally there are two options. You can either flash the eMMC chip on-board, or flash the SD card included with the kit. The eMMC runs faster but is not removable like the SD card. The SD card is easily removeable and can be programmed quickly and directly from a PC. It is up to you to choose which one to use.

NXP Images

The official source for linux on NavQPlus *will eventually be NXP Linux Factory, however at the time of this writing it is a work in progress.

See below for instructions on how to flash the SD card or eMMC.

Third party images

The following images are prepared by 3rd parties and support the NavQPlus.

• For use with iRobot Create3 (AKA Turtlebot4)

• For use with NXP MR-B3RB

The NavQPlus typically comes with a 16GB SD card or larger that you can flash with the pre-built Ubuntu 22.04 image. See below for instructions to flash your SD card on each platform.

Several free programs are available to flash an SD card with an image, we use .

Once you have downloaded Win32DiskImager, insert your SD card into your computer, open the program, and select the navqplus-image-{vX.X}.wic file as your image.

Next, select your SD card under Device.

Once the flashing process has finished, you should get a message saying that the write was successful.

To flash your SD card with the image you downloaded in step 1, we suggest using dd.

To do this, open a terminal and navigate to the folder that you downloaded the

navqplus-image-{vX.X}.wic file.

Once you are there, insert your SD card, and find the device path for it. Typically, it will be something like /dev/sdX on Linux or /dev/diskX on Mac.

Once you have found your device path, run the following command in your terminal to flash the SD card:

Once this is done, your SD card will be flashed with the image.

• Remember to check that your are set to boot from SD.

To flash the eMMC on your NavQPlus, you will need to download , a tool created by NXP to flash NXP boards. Make sure to download the correct application for your platform. The file titled "uuu" with no file extension is a binary file for use on x86/64 Linux.

• After downloading uuu, find the on your NavQ+ and flip them to the "Flash" mode.

• Connect NavQ+ to your computer using the centermost USB-C port.

• Run the following command to make sure that the NavQ+ is recognized by uuu:

<TODO: Add image of output>

• You should see that there is a device detected. If so, you can continue flashing. To flash your board, use one of the commands below depending on how the image was supplied:

• Once this process has finished, make sure that the flash was successful by comparing to the image below. If so, configure your to boot from eMMC.

TODO: Add image

An alternative tool to connect NavQPlus to your local Wi-Fi network is the nmtui command. This command presents a GUI in your terminal to connect to Wi-Fi. The interface is relatively straightforward. To run nmtui, run the following command:

The preferred method as mentioned earlier is to use the non-GUI way to connect to Wi-Fi or manage your network connections, use nmcli by running the following command:

Once you are finished connecting to your local WiFi network, you can exit the application. Your NavQPlus will continue to connect to this WiFi network even after a reboot.

Below are short examples of using openCV. Refer to NXP.com or other guides for more detail.

To install OpenCV for Python to the image, run the following command:

To access the Google Coral Camera(s) on NavQ+ in OpenCV, you may use the following VideoCapture instantiation:

You may change the source resolution by editing the width and height values in the GStreamer pipeline. See below for a list of supported resolutions and framerates.

The NavQPlus kit comes with an FTDI type USB-C to UART adapter cable and a small adapter board for this cable to the serial port JST-GH connector . This adapter is used for a serial debugging console on the NavQPlus.

Executive Summary: Connect the included USB to UART adapter to the UART2 port on the NavQPlus, and open your favorite serial console application (e.g. PuTTy for Windows users, Minicom on Linux). Open a serial console and set the baud rate to 115200. If there is no output on the screen, try to press enter to get a log-in prompt.

Connect USB cable+ adapter to your computer. Then plug in the JST-GH connector from the adapter into UART2 (A53 Debug/Console) port on NavQPlus.

Install I2C tools

If not already present, the first step is to install the I2C tools to be able to use the I2C ports.

sudo apt-get update -y

sudo apt-get install -y i2c-tools

Adjust I2C user group

To use the I2C commands without root, you'll need to add the NavQ+ user to the i2c group. To do this, you can run the following command:

sudo usermod -a -G i2c user

sudo su

echo 'KERNEL=="i2c-[0-9]*", GROUP="i2c"' >> /etc/udev/rules.d/10-local_i2c_group.rules

Check the I2C connection

Now to check the connection and confirm that the port is working correctly. Connect something to the I2C JST-GH port, then run the command below. It shoudl show you raw output from most devices connected on the I2C bus(es). Note that the onboard NXP secure element SE05x will not respond to this command.

i2cdetect -y 5

Example

Pipeline examples

Take an image

gst-launch-1.0 -v v4l2src num-buffers=1 device=/dev/video3 ! jpegenc ! filesink location=capture.jpeg

Record a video

gst-launch-1.0 v4l2src device=/dev/video3 ! imxvideoconvert_g2d ! "video/x-raw, height=640, width=480, framerate=30/1" ! vpuenc_h264 ! avimux ! filesink location='/home/user/video.avi'

Streaming examples:

• On PC: RX Pipeline to receive the stream from the NavQPlus AI/ML companion computer:

gst-launch-1.0 udpsrc port=50000 ! "application/x-rtp, media=(string)video, clock-rate=(int)90000, encoding-name=(string)H264, payload=(int)96" ! rtph264depay ! decodebin ! queue ! autovideosink

• On NavQPlus (e.g. from SSH connection):

gst-launch-1.0 v4l2src io-mode=dmabuf device=/dev/video3 ! "video/x-raw,width=1920,height=1080,framerate=(fraction)30/1" ! vpuenc_h264 ! h264parse ! rtph264pay ! udpsink host=10.0.1.101 port=50000

• Video Test Source instead of camera: gst-launch-1.0 videotestsrc ! "video/x-raw,width=640,height=480,framerate=(fraction)10/1" ! vpuenc_h264 ! h264parse ! rtph264pay ! udpsink host=10.0.1.101 port=50000

• Camera Tuning: 1) Get the video subdevice using:

media-ctl -p /dev/media0

remember the sub-device of the camera ( ov5645tn) in the media video chain, e.g. /dev/v4l-subdev2

2) List the available user and camera controls and try them out (e.g. contrast, saturation, auto white balancing etc.):

v4l2-ctl -l -d /dev/v4l-subdev2

• Streaming and Storing to a h264 compressed file simultaneously including text overlays for 30 seconds:

gst-launch-1.0 v4l2src io-mode=dmabuf device=/dev/video3 num-buffers=900 ! "video/x-raw,width=1920,height=1080,framerate=(fraction)30/1" ! tee name=t ! queue leaky=1 ! textoverlay text="Live" ! vpuenc_h264 ! h264parse ! rtph264pay ! udpsink host=10.0.1.101 port=50000 sync=false t. ! queue ! textoverlay text="recorded" ! vpuenc_h264 ! mpegtsmux ! filesink location=record_$(date +"%Y-%m-%d_%T").mp4

Note: The VPU is encoding two streams in parallel as we have different text overlays on the live stream and the recorded file

To avoid needing to set up a Wi-Fi router hostapd can be installed so that the NavQPlus acts as an access point. Additionally a DHCP server can be configured. This way you can directly connect to the WiFi network spawned by the NavQPlus:

Shown highlighted below, the IP address 10.0.1.101 is coming from the DHCP server on the NavQPlus.

Boot Switches Configuration

NavQPlus can be configured to boot from either SD card or eMMC. It also has a flash mode that allows you to flash either the eMMC or SD card over USB-C®. See the table below for the boot switch configuration.

This is an example of how to use a Webserver running locally on the NavQPlus. Note that this is one of several methods available. In this example the idea is to control the robot (or anything), using low level commands written with shell scripts commanded from an HTML page. By not using a higher level language such as Python it helps make the robot responsive and quick to act.

A WebServer is used to control the NavQPlus using low level commands written with shell scripts commanded straight from a HTML page. This page will explain how to set-up a WebServer and control your NAVQ+.

The webserver we will use is called Lighttpd, for more information on the Lighttpd read the following link:

First step is to install Lighttpd WebServer and components. Use the following code in your NAVQ+ serial console application:

This is the output you should receive after running all three codes above:

The official schematics for NavQPlus are published on:

A copy is provided here for convenience, but note that it is possible that it becomes out of sync/out of date with the official source. Please use the NXP official source for any critical requirements.

Note that NavQPlus is an open design using i.MX 8M Plus SOC from NXP. The SOM used is identical to the one on the larger NXP EVK. The carrier board includes a number of additional features and has its own BSP derivative in order to support these components. You are welcome to reproduce or modify the carrier board to your own specifications.

This is the main board for NavQPlus (8mpnavq) and can be used to reference the connectors and test points.

This SOM is identical to the NXP EVK SOM, with the exception that the IO are jumped for 3v3 voltage instead of 1v8

Please refer to the as it is most up to date on configuring a working simulation. Setup and scripts provided there will configure the envoronments for simulation

Vehicles using NavQPlus running ROS and other software can be modelled and simulated in Gazebo Ignition. There are several NXP models listed for the Ignition Fuel library here:

These models can be referenced "live" from within Gazebo-Ignition, or downloaded in advance.

Asimovo is a cloud based simulation environment that can offload the resource requirements for your local computer, as well as offering guided team collaboration and learning. They have experience using NavQPlus and our simulation models.

NXP Buggy3 RevB uses NavQPlus and the MR-CANHUBK344 together to form an Ackermann steering robotic development platform. Pre configured ROS2 and Zephyr Software to run this platform is provided. For best initial experience follow the MR-B3RB guide.

Use the MR-B3RB gitbook as a technical reference for NavQPlus when you are expanding upon the MR-B3RB or need to interface new peripherals.

This chapter will describe some of the hardware features present on the NavQ+.

This hardware interfaces section of the NavQPlus document is intended as a high level look at the connectors present on the board and their intended usage. Here we may also go into more detail where the interface is unique to the NavQPlus carrier board design and where it may differ from the i.MX 8M Plus EVKs. For complete in depth details regarding the IP block providing the specified interface please refer to NXP.com and the datasheet and reference manual for the i.MX 8m Plus system on a chip.

NavQPlus works with the ROS2 Turtlebot4 reference platform which is the iRobot Create3 platform. This includes Lidar interfacing.

Details on this setup can be found here: https://iroboteducation.github.io/create3_docs/hw/navqplus_hookup/

https://iroboteducation.github.io/create3_docs/setup/navqplus/

IX industrial ethernet defines a new rugged and small connector type for traditional 100BaseTX and 1000BaseTX interfaces. These traditionally would use RJ45 with plastic clips whereas IX industrial is primarily metal shell and clip design. The signals used are exactly the same and only the connector changes to the IX connector. Both IX-to-IX cables as well as IX-to-RJ45 cables are available off the shelf.. Plugging an IX-to-RJ45 cable into the NavQPlus will allow you to connect via ethernet to a laptop. An IX-to-IX would allow connection to the NXP ethernet switch board or similar industrial equipment. Note that the was was also made for mobile robotics with the intention of demonstrating the NavQPlus being able to connect to a multitude of T1 devices such as and cameras. The IX Ethernet interface on NavQPlus is capable of gigabit 1000BaseTX speeds.

There are two boards from the mobile robotics team that can also convert from T1 Ethernet back to a 100BaseTX:

There is an LED next to each CAN bus PHY on the board that will light up after running one of these commands.

These interfaces support the Linux SocketCAN library. Here is a good link showing some simple SocketCAN example code:

There are four CAN-FD connectors, they are connected "pass-through" style so that the bus may continue on, or a termination resistor network be plugged in.

Introduction

100BaseT1 2-Wire Automotive Ethernet provides 100MBPS connections over simple twisted 2 wires for a distance of up to 15 meters. The line signaling on the wire is not directly compatible with traditional 100BaseTX (RJ45) connections, but a physical adapter may be used. Otherwise it is the same as traditional Ethernet.

T1 is lightweight and reduces the cabling weight. The interface also does not require the use of magnetics, so it also saves weight and cost in that regard. Typically you will find T1 Ethernet used on Radar, Cameras, MR-CANHUBK3 and NXP flight controllers for drones.

This interface is compatible with the T1 Adapter for PC or other embedded devices RDDRONE-T1ADAPT and the MR-T1ETH8 network switch for robotics. RDDRONE-FMUK66 and FMURT6 also include T1 Ethernet

T1 Ethernet Locator

J18 is the T1 Ethernet connector and it should not be confused with the similar SE050 Secure-Element NFC connector at the opposite corner of the board. This is a JST-GH 2 pin heade. Technically there is a polarity associated with T1 Ethernet, but the TJA1103 Phy is configured to automatically and transparently swap the polarity as needed. It is still a good idea to attempt to maintain the correct polarity.

is the third-generation product of NXP’s successful family of 100BASE-T1 Automotive Ethernet PHYs. It is perfectly suited to support the rapid expansion of Ethernet to the edge of the network or provide robust connection to domain controllers in the center of the car.

complies with all state-of-the-art conformance test specifications and is designed according to ISO 26262 to meet ASIL B, providing enhanced monitoring and diagnostic features

Unlike traditional Ethernet, a heavy coupling transformer is not used. A small common mode choke and simple passive RC network is used for noise filtering. There is an ESD protection diode used and the communications signals are capacitively coupled. This overall lightweight, small size and cost optimized solution lends itself well to mobile robotics applications.

The Ethernet PHY itself is also extremely small:

There are two LEDS that connect directly to the TJA1103 PHY.

<TODO - additional description during operation>

Additional T1 Ethernet boards

The following boards also from the NXP Mobile Robotics team may be helpful when working with 100BaseT1 2-wire Automotive Ethernet. They are an adapter and a network switch. In addition to these baords, you may find other NXP EVKs and 3rd party boards that can also be used. In some cases you may need to adapt the two wire, two pin connector to match your own requrements.

This is a small dongle like board for quickly evaluating T1 Ethernet or to connect a laptop or sensor or companion computer with an RJ45 port into a 100BaseT1 port.

This is an 8-port switch using the automotive SJA1110 Safe and Secure 10 port Gigabit ethernet switch component. Two of the interfaces availeble on this switch IC that are typically used for direct bridging to MPUs are not used. Note that this board is for evaluation and not development. A full EVK board is available for development. The IX industrial interface is designed to directly connect with the Gigabit IX connector on NavQPlus.

UART4 is available for general use. Hardware flow control is supported.

Note from the schematic clip below, that the MPU can multiplex these signals with SPI2. This is normally configured in the Linux image, and is not the default configuration.

The signaling from the SOM to the NavQPlus carrier board on J11 is at 3V3

Alternative output is on the AUX connector at location J12 also at 3V3 signalling. However this is not the default linux BSP, and would require changes to the dtb files.

J11/UART4 is the default location for UART4 signals. Also by default UART4 is assigned to the M7 Core on the i.MX8M Plus. An RTOS such as FreeRTOS or Zephyr would normally use it as the default console to the embedded MCU.

UART2 by default is the Debug or Console port into the main A53 processors running Linux on NavQPlus. It is possible to reassign its use by modifying the Linux configuration and .dtb files.

The signaling from the SOM to the NavQPlus carrier board on J10 is at 3V3. Full handshaking with CTS RTS lines is provided:

Normal configuration and usage of UART2 is a console for bootup and Linux. The benefit of using the debug/console is that you can observe all details from powerup.

Details of the console connection including the Baud rate are provided under "Serial Console" in the Quickstart section of this gitbook. See the link below:

UART1 is assigned to communicate with the Bluetooth portion of the WiFi/BT Wireless module on the NavQPlus Baseboard. Therefore it is not available for general use (outside of creating your own modified custom baseboard).

The signaling from the SOM to the NavQPlus carrier board on J16 is at 3V3 but the Murata 1ZM expects 1.8V. The level conversion is done using U26.

The module is using the NXP 88W8987 chipset. Type 1ZM is a small and very high-performance module based on NXP 88W8987 combo chipset which supports Wi-Fi® 802.11a/b/g/n/ac + Bluetooth® 5.1 BR/EDR/LE up to 433Mbps PHY data rate on Wi-Fi® and 3Mbps PHY data rate on Bluetooth®. The WLAN section supports SDIO 3.0 interface and the Bluetooth® section supports high-speed 4-wire UART interface and PCM for audio data.

The 88W8987 implements highly sophisticated enhanced collaborative coexistence hardware mechanisms and algorithms, which ensure that WLAN and Bluetooth® collaboration is optimized for maximum performance.