A big thank you to Dr. Pan from Gravitech (Thailand) for providing me a new Arduino UNO Q board to test. I wanted to share my unboxing experience and show how to get a basic edge AI example running.
Unboxing...Looking at the board from the front, it looks similar to the Arduino UNO R4 WiFi. It features two main chips: the Qualcomm QRB2210 (next to it is likely Micron LPDDR RAM) and the silver-cased chip, the WCBN3536A (Qualcomm's own communication module). This is a WiFi5 + BT5.1 communication chip, which is expected since Qualcomm is a major supplier of communication modules for smartphones and computers.
When I flipped the board, I immediately spotted two unusual ports that distinguish it from the original Arduino UNO lineage: JMISC (for high-speed digital + sound) and JMEDIA (MIPI DSI for cameras). These ports open up connections for the QRB2210 to interface with other peripherals. However, special care must be taken as the main chip system uses 1.8V.
On the back of the board, the main chips are a Kingston eMMC (the large one) and an STM32U585 (the small one). The traditional Arduino headers (D0-D13 and A0-A5) are likely connected to the STM32U585, as the website says these pins operate at 3.3V (5-V tolerant). This provides a level of confidence that older 5V Arduino peripherals won't be immediately damaged when connected.
Getting started!The Arduino website has a dedicated page for the Arduino UNO Q, suggesting three usage modes:
- SBC Mode: Using it as a standalone computer. Anyone familiar with the Raspberry Pi will recognize this: connect a keyboard, mouse, and monitor. The difference is that a Raspberry Pi has separate USB and HDMI ports, but the Arduino UNO Q only has a single USB-C port. This requires an external helper: a USB-C hub with separate power input—which I happened to have.
- PC Mode: Connecting to a computer via the USB-C port, similar to a regular Arduino board. This is done through the dedicated Arduino App Lab application developed specifically for the UNO Q.
- Network Mode: Connecting via WiFi after setting up in either SBC or PC mode. Don't try this one yet.
I chose to test the UNO Q by connecting through the USB-C port, as this setup is more likely for an edge AI use case. It also seemed like the easiest way to start without needing to find a USB-C hub with a power slot. Setup begins with three steps, familiar to anyone who has used a Raspberry Pi:1. Select the keyboard and set the host name2. Select the network3. Set a password (the username is locked as arduino).
Once the basic settings are complete, you'll see a screen listing example applications. This feels different from a Raspberry Pi, which uses a Desktop GUI (if a monitor is connected) or a command line in the terminal (headless mode).
Clicking into an application shows details about the hardware and the code. In terms of user-friendliness, it's hard to say if it's suitable for high school or younger students, as the reader might get slightly confused by the two code formats: Python on the QRB2210 and Arduino on the STM32U585.
The first application to try is the Blink LED example, as it requires no extra hardware and is a good way to observe the toolchain in action. Trying an example app in the Arduino App Lab is extremely easy because you don't need to write any code. Just press the Run button in the upper right corner.
The terminal output during the STM32U585 image creation reveals several interesting points:
- Zephyr RTOS: The Arduino environment is built on Zephyr, an RTOS that might be less known compared to FreeRTOS but is widely used in production, especially with Nordic microcontrollers. Zephyr's strengths include a comprehensive stack covering communication protocol middleware and excellent low-power support. Arduino and Qualcomm's choice of Zephyr as the foundation for the STM32U585 software opens up significant possibilities for integration with various existing Arduino shields.
- OpenOCD: The use of OpenOCD for uploading and controlling the board is interesting. We'll need to explore the extent of debugging capabilities supported from the QRB2210 side.
- Containers: The word "container" appears in several places. It's unclear if this refers to Docker running on the QRB2210 side or a light-weight container running on the STM32U585. This will require further investigation.
- STM32U585 Specs: From the build report, the STM32U585 has 2 MB of Flash memory and approximately 512 kB of usable RAM. STMicroelectronics' website indicates the STM32U585 can operate up to 160 MHz, a specification that significantly surpasses the UNO R4.
When you run the app, the red LED on the board blinks, turning on for 1 second and off for 1 second. Examining the main.py and sketch.ino files via the left-hand menu shows that the on/off timing is controlled by the time.sleep(1) command on the Python side. Critically, the Arduino code does not directly call digitalWrite() to control the LED; the loop() function is empty. Instead, an set_led_state() function is declared in the setup() function, which is enabled for remote command execution using the RPC mechanism via Bridge.provide() and Bridge.call().
I used the Blink LED example as a code template by pressing the [Copy and edit app] button in the upper-right window, creating a new app with the same code structure. I then experimented by modifying the code for reverse communication: calling Bridge.call() from the Arduino side to instruct the Python side to print a message and blink the LED, while also trying Bridge.provide() on the Python side. The results matched my expectations. So, two-way communication between Python and Arduino is possible!
The Dragonwing QRB2210 features a quad-core Cortex-A53 belonging to the processor class for smartphone devices, meaning it comes with a full-fledged operating system. Arduino and Qualcomm have chosen to use Debian Trixie version 13.1 (checked via cat /etc/debian_version), running a 6.16.7 kernel (checked via uname -a). This is very recent, considering its release date of September 6, 2025.
Why was I able to type commands to check the OS status? It's not because the Arduino App Lab supports a command-line interface feature, but because the Arduino UNO Q board supports connection via ADB (Android Debug Bridge). This allows you to log into the board directly through the USB connection. Once logged in, you can execute various Linux commands, bringing the usage of the Arduino UNO Q much closer to that of a Raspberry Pi.
To install the ADB program, download the Android SDK Platform-Tools from the website and extract the files. When running it (via cmd or PowerShell on MS Windows), a few commands are essential:
./adb devices: Displays a list of connected devices../adb shell: Connects and logs into the device. For the Arduino UNO Q connected via the USB port, this automatically bypasses the password prompt.
After logging in, the first command you should type is bash to activate the bash shell, which makes usage much easier.
Arduino has set the default user as arduino. When you type the cd command, it jumps directly to the user's working folder: /home/arduino. If you create new apps (like copying the Blink LED app earlier), you will see the ArduinoApps folder, which contains sub-folders for each app you create. Inside these, you'll find python and sketch sub-folders for the respective system codes.
Using the df command shows that out of the 16 GB eMMC space, approximately 3 GB remains for the root partition (/) and another 3 GB for the development area (/home/arduino). Since it runs Debian, UNO Q users should be familiar with basic Linux commands, which may be learned from Raspberry Pi documentation. Examples of frequently used commands include:
aptcommands for package management:sudo apt updateto update the package listsudo apt upgradeto update packages to the latest versionsudo apt install <package>to install a package.apt-cache search <condition>to search for packages matching a condition.ip linkto display the list of interfaces, andip addrto display IP addresses.
As the goal of this article is to use the UNO Q as an edge AI device, I installed the necessary packages using the apt command. Although these versions might not be the very latest, they are generally less prone to issues than installing with Python's pip command:
sudo apt install python3-opencv python3-numpy python3-scipy python3-pandas
After installation, testing can be done by typing the python3 command and attempting to import the modules.
Zephyr is the RTOS (Real-Time Operating System) installed for the STM32U585 processor on the UNO Q board. A key advantage of using Zephyr RTOS with Arduino is the small size of the image built by the Zephyr SDK. For example, the Blink LED code, including the RPC feature for Python communication, is only 18 kB and uses 4.6 kB of RAM, which is minimal compared to the STM32U585's total memory.
The hardware support for the UNO Q board within Zephyr appears to be comprehensive, likely ported directly from the STM32U585 itself. Hardware references for the chip or the board can be found in the Device Tree files. Since the board includes Zephyr RTOS, I wanted to try writing code that uses the native Zephyr API to control the LEDs via GPIO. The UNO Q board has four RGB LEDs, with two sets of three GPIO pins controllable by the STM32U585 (6 pins total). Checking the Device Tree file reveals the LED access description:
leds {
compatible = "gpio-leds";
led3_red: led3_red {
gpios = <&gpioh 10 GPIO_ACTIVE_LOW>;
label = "RGB LED 3 Red";
};
... (other color definitions) ...
led4_blue: led4_blue {
gpios = <&gpioh 15 GPIO_ACTIVE_LOW>;
label = "RGB LED 4 Blue";
};
};I wanted to control two LEDs, blinking them alternately: led3_blue and led4_green. I studied the Zephyr Blink example and made some adjustments:
#include "Arduino_RouterBridge.h"
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
static const struct gpio_dt_spec led3 = GPIO_DT_SPEC_GET(DT_NODELABEL(led3_blue), gpios);
static const struct gpio_dt_spec led4 = GPIO_DT_SPEC_GET(DT_NODELABEL(led4_green), gpios);
void setup() {
gpio_is_ready_dt(&led3);
gpio_is_ready_dt(&led4);
gpio_pin_configure_dt(&led3, GPIO_OUTPUT_ACTIVE);
gpio_pin_configure_dt(&led4, GPIO_OUTPUT_INACTIVE);
Bridge.begin();
}
void loop() {
Bridge.call("print_hello");
gpio_pin_toggle_dt(&led3);
gpio_pin_toggle_dt(&led4);
delay(1000);
}The code is slightly more complex than standard Arduino because the hardware abstraction method is different. It starts by declaring gpio_dt_spec structure variables, referencing led3_blue and led4_green. Then, in setup(), it instantiates them and configures them as outputs. Inside loop(), the gpio_pin_toggle_dt() function is called to blink the LEDs. Overall, it was not so much complicated, so using other hardware not officially supported by the Arduino API should be feasible.
The Arduino UNO Q presents a compelling package with its dual-processor hardware and significantly more complex software platform than traditional Arduino boards. The combination of Debian Linux on the QRB2210 and Zephyr RTOS on the STM32U585 opens up a wealth of possibilities. We've confirmed the ability to install additional software on the Debian side via ADB and write low-level code that accesses hardware using the native Zephyr API. This setup sparks ideas for advanced projects, such as dual-ML where the STM32U585 handles machine learning on sensor data from Arduino shields while the QRB2210 processes multimedia AI from the camera or microphone. This capability has wide-ranging application potential.
Comments