RoadTest: Test out Arduino's Uno Q - The new Single-Board Computer!
Author: amgalbu
Creation date:
Evaluation Type: Development Boards & Tools
Did you receive all parts the manufacturer stated would be included in the package?: True
What other parts do you consider comparable to this product?: Raspberry Pi (as far as the Linux OS is concerned), Latte Panda (as hybrid system)
What were the biggest problems encountered?: No problems: it's very easy to get started and start creating your own project. Tutorial and manuals are very clear and guide you through
Detailed Review:
Overview
The Arduino Uno Q is best described as a hybrid development board: a single-board computer running Linux paired with a dedicated microcontroller for compiled C++ execution. Rather than positioning itself as a raw performance competitor in the SBC market, it can be more seen as a versatile development platform, which integrates the determinism of embedded programming with the flexibility of a general-purpose Linux environment.
Let's go quickly through the hardware specifications, because, as I said, this is not the thing this board shines for
Hardware Specifications
Main processor (Dragon SoC)
A Qualcomm Dragonwing
QRB2210, which features four ARM Cortex-A53 cores and an Adreno GPU, handles the Linux environment. The board ships in two configurations — 2 GB RAM / 16 GB storage and 4 GB RAM / 32 GB storage — giving it enough computational power for light desktop use, data processing, local web servers, and running small inference models.
Microcontroller
The onboard MCU is a STM32U585, which sports a Arm Cortex M33 with a clock up to 160 MHz. This MCU runs C++ executables on Zephyr OS, which is really forward-looking approach to real-time subsystems. The application, thanks to this lightweight and deterministic OS, can leverage real-time access to hardware peripherals.
Power consumption
Idle power sits around 2–2.5 W, rising to approximately 4–5 W under full load. This is notably lower than competing SBCs, making battery-powered deployments — like portable sensor nodes — feasible without complex power management.
Connectivity
A single USB-C port handles power and data. For desktop use, a PD-capable USB hub is necessary to connect a keyboard, mouse, HDMI display, and any USB peripherals simultaneously. Despite the Arduino docs suggests to use the board as a "PC replacement" (i.e. with display and keyboard), I think you get the most out of this board if you use App Lab and a console. Running a fully-fledged desktop environment pits too mush load on the CPU, and causes slow downs and (sometimes) unexpected reboots. At least, this is what I experienced with my 2 Gb version. Hopefully, the 4 Gb version is more usable and stable
Connectors
The board features, beside the typical digital and analog signals on the Arduino Uno headers, high-speed expansion connectors on its underside for cameras, displays, and audio modules, plus a quick connector for common peripheral hookups.
Form factor
The Arduino Uno Q has a Uno-compatible footprint, meaning existing Uno shields should work — an important consideration for anyone with an existing parts collection. To be honest, I don't expect any of the Uno shields to work with Arduino Q. Arduino Uno was a 5V-compatible microcontroller, whereas the Qualcomm CPU runs at 1.8V and the STM32 MCU runs at 3.3V. Happy to be proven wrong, but just this simple consideration makes me very doubtful about the compatibility statement. Anyway, here are the compatible shield according to the Arduino website
https://docs.arduino.cc/hardware/uno-q/#compatibility
LED Matrix
The board also features a programmable LED matrix, which is somehow scenographic but I don't think it's really useful. First of all, if you mount a shield all the LEDs will not be visible. Second, the information you can show on LED matrix are limited. Considering the cost of the components (resistors and LEDs) and the cost of manufacturing, a tiny 2.8" OLED display would have been cheaper to install
Performances
To be clear and direct, Uno Q is not, as other general-purpose SBC, a desktop replacement. Light web browsing and text-based tasks are usable; YouTube playback is sluggish. Any comparison with Rapserry Pi 5 purely in terms of raw Linux performances will see the Raspberry as the absolute winner.
Regarding performances, I found this interesting comparison
In summary:
| Idle power draw | 0.5 W |
| Maximum simulated power draw (stress-ng --matrix 0) | 1.9 W |
| During Geekbench multicore benchmark | 2.5 W |
| During top500 HPL benchmark | 3.5 W |
In terms of number crunching capabilities, the Arduino Uno Q is comparable to a Raspberry Pi 4 (an SBC relased in 2019)
In terms of efficiency, results are much better
As we can see, Arduino Uno Q is not the best in class in terms of performance or even efficiency, but this point of view misses the product's intent. The Uno Q should be considered as a microcontroller-based board that happens to run Linux, not a Linux computer with GPIOs. The absence of a heatsink, the default boot into AppLab rather than a desktop, and the Uno form factor provides an idea of the product the development team had in mind.
However, if the focus was on creating a maker-friendly hybrid system, in my opinion the board is missing the ability to keep only the MCU running and wake up the Linux processor only when something "interesting" is detected. This feature could have opened a whole branch of battery-based intellingent sensors.
The Microcontroller Advantage
Having a microcontroller introduces a significant differentiator: determinism. When you control GPIO through a Python script running on Linux, you are only suggesting the desired timing to the OS scheduler. Other processes (like network handling, display rendering, or memory management) can prevent OS scheduler from meeting the deired timing because they all may introduce unpredictable latency.
The onboard MCU executes each instruction with predictable, repeatable timing. This matters significantly for a wide range of sensors and peripherals that can be easily integrated into the Arduino sketch
AppLab IDE
Let's now see how one can develop its own projects on Arduino Q. The central piece of software is AppLab, which greatly simplify the integration of software running on Linux, real-time Arduino application running on MCU and the web interface that allow users to interact with the application itself.
AppLab runs either directly on the Uno Q's Linux environment or, more comfortably, on a host computer connecting to the board via USB or local network. Here are the connections required for the two different, called, in the Arduino documentation, "Standalone mode" and "PC Hosted mode"
A typical project in AppLab contains:
Python scripts and the optional web UI runs in docker container. When you run a project, you will see in the terminal familiar log messages of docker downloading images from docker repositories.
The containerisation means dependencies are isolated and the brick simply exposes an interface to your code. Importantly, the user does not need to manage Docker directly; AppLab handles deployment automatically.
One thing that makes me wonder whether the development team has selected the right approach for application deployment: Docker images are downloaded to the so-called "root" partition, which stores all the critical Linux system files.
I would have preferred the user data and application to be downloaded in a separate partition. This solution has some benefits
Regarding eMMC partitioning, I worth noticing that that are an incredible number of partitions, but only three are really mounted
It's not clear to me what all those partitions are for, but the finally effect is that you only have 13 Gb available out of 16 Gb
Bricks
Bricks are the most distinctive AppLab concept. They are pre-packaged functional modules — not just libraries — that run as separate processes (often in Docker containers) alongside your application. Examples include weather API fetchers, voice keyword detection, sentiment analysis, and YOLO object detection. This architecture means a single project file can orchestrate Python business logic, a C++ hardware loop, and a Docker-hosted ML model
The bridge system
The bridge system is what ties the two processors together. A library (called ArduinoBridge) is available as both Python and Arduino library. By invoking the methods of the Bridge class, the application that runs on Linux and the Arduino sketch can exchange data. For example, the `bridge.notify()` call in the microcontroller sketch passes data across to the Python process — cleanly abstracting what would otherwise require a raw UART or USB serial handshake.
Hands-on project
It's time to get our hands dirty and create a simple project to assess Arduino Q performs in the real world. I will create a project that captures video using a USB webcam, detects the position of a person and moves a servo to keep the person in the center of the camera frame.
Running App Lab
The App Lab can be run in three different ways:
One crucial concept to understand is that app files reside on the Arduino Uno Q itself, not on your local PC. The App Lab doesn’t make a local copy – it edits files directly on the board. You’ll find these files in the Linux partition at /home/arduino/ArduinoApps/.
Even when you run App Lab on your computer, it’s connecting to and editing files that live on the Arduino Uno Q. This is an important distinction from traditional Arduino development.
AppLab has a good example to start from: the face detection example. This example uses ML models to detect faces in the scene.
Let's make a copy of this project and start tinkering with the code.
The object detection is implemented by a brick, where several parameters can be adjusted to fit your needs. Among the other things, the object detection supports different models, even custom models created on Edge Impulse
The example project I started from does not include any Arduino sketch. When you create a new project, AppLab takes care to generate the complete folder hierarchy, but, in this case, the "sketch" folder was missing. The only workaround I found was to copy the "sketch" folder from another sample project.
The sketch have just to get face coordinates left or right to try to keep the face at the center of the scene. To let Linux processor and MCU communicate, AppLab provides a library called ArduinoBridge. The ArduinoBridge implements the following functions
To implement the MCU side of the bridge, you need to initialize the bridge and declare which functions can be invoked by the processor
void move_servo(int pos)
{
...
}
void setup()
{
if (!Bridge.begin()) {
Serial.println("cannot setup Bridge");
}
Bridge.provide("move", move_servo);
}
Note that the move_servo may be executed independently from the loop() function. This may cause undesired race conditions when the function interacts with functions, like digitalWrite(). If you want the move_servo function to be executed in the context of loop() function, user provide_safe instead.
On the processor side, import the Bridge class from the Python arduin.app_utils library, and invoke Bridge.call to send a request to the sketch
from arduino.app_utils import Bridge
Bridge.call("move", pos)
Bridge.call invokes a function and wait for the function to complete. If you want to just invoke a function without waiting for completion, the Bridge.notify method is available.
Load of details about the bridge are available at the following links
https://docs.arduino.cc/tutorials/uno-q/routerbridge-multilanguage/
https://docs.arduino.cc/tutorials/uno-q/user-manual/#bridge---remote-procedure-call-rpc-library
Use Case Assessment
After a couple of weeks playing around with the Arduino Uno Q board, I realized which projects this board is fit for
Perfect fit
Not so perfect fit
Completely unfit
Conclusions
The Arduino Uno Q provides a clean hardware solution for all the projects that need both real-time hardware control and a capable compute environment in one compact, low-power package. AppLab significantly lowers the integration complexity that you may expect when coping with an hybrid (CPU + MCU) solution. Also, the integration with Edge Impulse is a plus that should be considered when approaching a ML-based project.
PROS
CONS
Top Comments
Informative benchmarks!
High stakes, expecting good things ;)
Good review. I like the "where the Q works and where it doesn't" assessment. That works for my brain.