Arduino Uno Q – Getting Started

In this article, the first in a two-part series, we’ll be looking at Arduino’s unique new microcontroller/microcomputer product, the Arduino Uno Q. Today, we’ll get familiar with the hardware, power it up, update its firmware and OS from the command line, and run some example Apps using Arduino App Lab. We’ll also look at how Apps and Bricks fit together, and we’ll finish by trying different hookup options – from a “regular” USB connection to complete standalone SBC and network modes.

In the next installment, we will take a deep dive into the Arduino App Lab, the application used to develop apps for the new Arduino Uno Q.

Introduction

The Arduino Uno Q is not just “another Uno.” It’s a new hybrid board that combines a Linux single-board computer with a real-time microcontroller on a single PCB. Inside, you have a Qualcomm Dragonwing QRB2210 processor running Debian Linux, plus an STM32U585 microcontroller running – sketches under Zephyr OS.

Wireless connectivity is handled by an on-board WCBN3536A module that gives you dual-band Wi-Fi 5 (2.4/5 GHz) and Bluetooth 5.1, both with built-in antennas.

Announced in October 2025 as part of Qualcomm’s acquisition of Arduino, the Uno Q represents an entirely new direction for the Arduino platform. It’s not just a microcontroller board anymore – it’s a hybrid system that combines a powerful microcomputer running Linux with a real-time microcontroller, all in the familiar Uno form factor.

The whole platform is tied together by Arduino App Lab and the Arduino_RouterBridge library. Your App can run Python on the Linux side and C++ on the MCU side, while the Router Bridge handles message passing between the two.

In this first article, we’re going to get you up and running with the Uno Q. We’ll explore the hardware, learn how to set it up, understand the revolutionary new Arduino App Lab development environment, and run some example applications. By the end of this tutorial, you’ll be ready to start building your own projects that combine the best of both worlds: high-performance computing and real-time control.
So let’s get started!

Arduino Uno Q

The Uno Q shares the same classic form factor as the Arduino Uno R3 and R4, but under the hood, it is significantly different.

The “Q” stands for Qualcomm, and the star of the show here is the Qualcomm Dragonwing QRB2210. This is a powerful, quad-core microprocessor (MPU) running a full version of Debian Linux. It handles high-level tasks, image processing, and AI.

But Arduino hasn’t forgotten its roots. Paired with that Qualcomm chip is an STM32U585 microcontroller (MCU). This is a robust, real-time processor that handles the GPIO pins, ensuring the precise timing we expect from an Arduino.

Think of it as having two complete computers on one board, each optimized for different tasks.

The Microprocessor Unit (MPU) – Qualcomm Dragonwing QRB2210

A powerful Qualcomm system-on-chip (SoC) runs a Linux-based operating system. This handles complex tasks, networking, graphical user interfaces (GUIs), and high-level application logic.

• Quad-core ARM Cortex-A53 processor running at 2.0 GHz
• Adreno 702 GPU for graphics acceleration
• Dual Image Signal Processors (ISP) supporting up to 13MP + 13MP or 25MP cameras
• Runs a full Debian Linux operating system
• Handles complex tasks like AI processing, image recognition, web servers, and more

The Microcontroller Unit (MCU) – STM32U585

The STMicroelectronics STM32U585 microcontroller manages GPIO pins, analog reads, PWM, and communicates with sensors and actuators. It’s your direct interface to the physical world.

• ARM Cortex-M33 processor running at up to 160 MHz
• 2 MB of Flash memory
• 786 KB of SRAM
• Runs Arduino sketches using the Zephyr real-time operating system
• Handles time-critical tasks like reading sensors and controlling actuators

These two processors work together seamlessly, connected through Arduino’s Bridge library. You can write a Python program on the Linux side to do complex image processing while simultaneously running an Arduino sketch to control motors in real-time.

Memory and Storage

The Uno Q comes in two configurations:

• Entry Model – 2 GB LPDDR4 RAM with 16 GB eMMC storage
• Pro Model – 4 GB LPDDR4 RAM with 32 GB eMMC storage (currently not available)

This built-in storage eliminates the need for SD cards and provides fast, reliable storage for your operating system and applications.

Connectivity

The Arduino Uno Q has many ways to connect to the outside world, both wired and wireless.

Wi-Fi and Bluetooth

The WCBN3536A wireless module provides:

• Wi-Fi 5 (802.11ac) dual-band (2.4 GHz and 5 GHz)
• Bluetooth 5.1 with BLE support
• Onboard antenna for reliable connectivity

USB-C Port

The USB-C connector is incredibly versatile:

• Power input (up to 3A at 5V)
• Data communication with your computer
• Power Delivery support
• Video output (with appropriate USBC Hub adapter)
• Can act as a USB host for keyboards, mice, cameras, and more

Qwiic Connector

A Qwiic/STEMMA QT connector allows easy plug-and-play expansion with Arduino’s Modulino modules and other I2C devices – no soldering required!  This is a 3.3-volt I2C bus connection.

GPIO and Expansion

The Arduino Uno Q has the same I/O connections and layout as the other Arduino Uno series boards. It also has additional expansion connectors.

Standard Arduino Headers

The Uno Q maintains full compatibility with the classic Arduino Uno pin layout:

• 14 digital I/O pins (operating at 3.3V but 5-volt tolerant)
• 6 analog inputs (Not 5-volt tolerant)
• I2C, SPI, and UART interfaces
• Compatible with voltage-appropriate Arduino shields

High-Speed Expansion

On the bottom of the board, you’ll find high-speed connectors for:

• MIPI-CSI camera interfaces
• MIPI-DSI display connections
• Analog audio input and output
• Additional GPIO from the MPU

These require carrier boards but open up possibilities for advanced projects with displays and cameras.  Unfortunately, as of this writing, no expansion boards are available.

LEDs & Indicators

The board includes some nice visual features:

• 8×13 LED matrix display
• Four RGB LEDs
• User button for interaction

Setting up the Uno Q

So let’s get started with the Arduino Uno Q!

The only items you’ll need to follow along are a Computer (Windows 10/11, macOS 11+, or Ubuntu 22.04+), an Arduino Uno Q board, and a USB-C cable. The computer will need to be connected to the internet, and you should have a Wi-Fi network and its credentials handy.

Hooking up the Arduino Uno Q

We will operate the Uno Q in “PC Mode”, which means that you connect the Uno Q to your computer using the USB-C cable.  The same way you would usually connect a microcontroller.

Make sure the USB-C cable you are using is rated for both power and data; some cables are just power-only and don’t pass data well.  And connect the cable to a USB-C or USB3 port on your workstation for best results.

Get the Software

The first step is to visit Arduino’s software download site. You’ll want to download two pieces of software:

• Arduino App Lab
• Arduino Flasher CLI

Make sure to download the version of each application for your computer; it should be selected automatically.

Updating the Firmware

Now that you have downloaded the software, you can begin by using the Flasher CLI to update the Arduino Uno Q firmware. This is an essential step, as there have likely been several firmware updates since your board was manufactured.  You can also flash the board to “erase” it and start fresh. Remember, the flashing operation will wipe out everything on the board, so be sure you want to do that.

Set up Flasher CLI

The Flasher CLI file you downloaded is a compressed ZIP file. Unzip it using your favourite utility, and place the extracted files in a folder you can remember.

Use a Terminal (Command Prompt) and navigate to the folder containing the flasher-cli executable.

On MacOS or Linux, run the folowing command:

You will see a screen displaying the syntax for the flasher-cli utility.

If you are using Windows, run the following at the command prompt:

You will be prompted to install a driver, accept the prompt, and install it. You will then be taken to the flasher-cli syntax screen.

Preparing the Uno Q for Flashing

You will need to prepare your Arduino Uno Q board for flashing.  You do this by inserting a jumper or jumper wire between the two end pins of the JCTL connector, as shown here.

Once your board is prepared, you can plug it into the computer.

Flash the Board

Open your Terminal or Command Prompt and navigate to the folder where you extracted the flasher-cli utility. Run the following command:

This will start a download sequence. It can take several minutes, as the file is over a gigabyte. Just wait and let it do its thing. Do not disconnect the USB cable or interrupt the process.

Once it is finished, you can unplug the Uno Q, remove the jumper, and then plug it back into your computer. The board should go through a boot sequence, terminating with the Arduino logo on the LED matrix display.

Install App Lab

The Arduino App Lab is an integrated development environment specifically tailored to the Uno Q. It allows you to build “apps, programs that utilize both the microcomputer and microcontroller sections of the Uno Q board.

The App Lab is already installed on your Arduino Uno Q board and runs in the Linux segment. You can also install it on a computer and use it with either a USB or network connection to the board. This is how we work with the Uno Q in “PC Mode”.

You have already downloaded the App Lab installation program suitable for your operating system, so now is the time to install it:

• Windows –  Run the installer and follow the prompts
• MacOS – Drag the application to your Applications folder
• Linux – Extract the archive and run the AppImage

Install that App Lab application. Unplug your Arduino Uno Q from the computer and start App Lab.

Run App Lab

When App Lab starts, it will look for an Arduino Uno Q.  Plug in your board and wait a moment.

When you plug in a brand new (or freshly imaged) Arduino Uno Q, it will display a moving “Arduino Logo” on the matrix display. Once it is connected to the App Lab, the display will turn into a pulsing heart, and the App Lab screen will display information about the Uno Q.

The first time you connect, App Lab may need to install board support packages and update firmware. This can take a few minutes.

Once this is done, you will be taken to the default App Lab screen.

You will probably be prompted to download and install some updates. These can be for either (or both ) of the following:

• The App Lab installation on your local PC (the one you are running right now)
• The App Lab installation on the Linux half of the Arduino Uno Q board.

Accept the prompt and download and install the files; it’s done automatically, and there are no questions to answer.  After the update, you will be prompted to restart App Lab.

Apps & Bricks

One of the most innovative features of the Uno Q ecosystem is the concept of Apps and Bricks. This represents a fundamental shift in how we think about Arduino development.

What are Apps?

In traditional Arduino development, you write a sketch, upload it, and it runs. Apps take this further by bundling together:

• One or more Arduino sketches for the microcontroller.
• One or more Python programs for the Linux side.
• A configuration file (YAML) that describes how everything fits together.
• Optional Bricks that add services like AI, databases, web dashboards, or cloud APIs.

App Lab illustrates Apps as a project tree. There are folders for the MCU code, Python code, web frontend files, and a list of configured Bricks.

When you press Run, App Lab compiles the sketch, builds the Python environment, sets up all the Bricks defined in the app configuration, and then launches both sides together. You can watch logs from both the MCU and the MPU in the console.

An App is a complete, self-contained project that coordinates both processors. For example, a weather station App might:

• Use Python to fetch weather data from the internet and display it on a web interface (MPU)
• Use an Arduino sketch to read local sensors and control an e-paper display (MCU)

What are Bricks?

Bricks are modular, reusable components that you can add to your Apps. Think of them as plug-and-play functionality blocks that you can use in your App design. Some examples:

• Web Server Brick – Adds a web interface to your project
• Camera Brick – Provides camera input and image processing
• Object Detection Brick – Adds AI-powered object recognition
• Climate Brick – Handles temperature and humidity sensing with Modulino modules

Bricks handle all the complexity behind the scenes. Instead of writing hundreds of lines of code to set up a web server or configure an AI model, you simply add the appropriate Brick to your project and customize it for your needs. You can think of Bricks as pre-wired “services” you snap into your App, rather than writing everything from scratch.

How They Work Together

The relationship between Apps and Bricks is simple:

• Apps are complete projects
• Bricks are the building blocks you use to create Apps

When you open an example App, you can see which Bricks it uses. You can then modify those Bricks, add new ones, or remove ones you don’t need.

Example Apps

The App Lab comes configured with several example applications.

Blink App

The Blink App is Arduino’s classic “Hello World” example reimagined for the dual-processor architecture of the Uno Q.

While it may seem simple on the surface, this App elegantly demonstrates the fundamental concept of how the MCU and MPU sides work together. On the Arduino (MCU) side, you’ll find familiar code that controls one of the onboard LEDs, toggling it on and off at regular intervals – just like the traditional blink sketch you’ve run on countless Arduino boards.

However, what makes this App special is the Python code running simultaneously on the Linux (MPU) side. The Python script monitors the LED state through the Bridge library, logs each blink event with a timestamp, and can even serve a simple web page showing the blink count and current state. This seemingly trivial example is actually profound – it shows that even the simplest Arduino functionality can be enhanced with the computing power of Linux.

You can see the LED blinking in real-time while simultaneously tracking statistics, serving web interfaces, or processing data in ways that would be impossible on a traditional microcontroller.

Weather on LED Matrix

The Weather on LED Matrix App is a delightful example that showcases the Uno Q’s ability to present cloud-sourced information on physical hardware, transforming the board’s built-in 8×13 LED matrix into a miniature weather display. This App brilliantly demonstrates how data from the internet can be visualized on embedded hardware without requiring any external displays or monitors.

On the Python (MPU) side, the application connects to a weather API service to fetch current conditions and forecasts for your configured location – retrieving information like temperature, weather conditions (sunny, cloudy, rainy, etc.), and potentially wind speed or humidity. This data is processed and simplified into formats suitable for the limited but charming LED matrix display, then sent across the Bridge to the Arduino side.

The MCU receives these weather updates and translates them into visual patterns on the LED matrix, showing animated icons representing weather conditions (a sun for clear skies, clouds for overcast, raindrops for precipitation), or cycling between different data points every few seconds.  This example does not show temperature and humidity, but it could be modified to do so.

What makes this App particularly engaging is how it solves the challenge of presenting complex information on a tiny display through clever use of icons, animations, and scrolling text.

Alternate Hookups

There are three main ways to work with the Uno Q:

• PC Mode – Uno Q connected to your computer via USB-C, with App Lab running on the PC.
• SBC Mode – Uno Q used as a standalone Linux desktop with a USB-C dock, monitor, keyboard, and mouse.
• Network Mode – Uno Q on your Wi-Fi network, App Lab running on another machine, and connecting over the network.

Up to this point, we have been running our Uno Q in PC Mode. Let’s look at the other two hookup methods.

SBC Mode

In SBC mode, you treat the Uno Q like a small desktop computer. With a USB-C hub, you can plug in an HDMI display, keyboard, mouse, USB storage, a USB camera, and even a USB headset.

You will require a hub with a USB-PD power input. Please do not use the Apple USB dongle, as it is incompatible with the Uno Q.

A couple of hubs that I have tested and know to work are as follows:

• Anker USB-C Hub – a solid performer.
• Noovoo USB Hub – a great value, and includes an Ethernet port.

You hook the hub, monitor, keyboard, mouse, and Uno Q together as follows:

You will need your Linux credentials to log in. Once you do, you will have a complete Debian Linux desktop with a copy of the App Lab.

Network Mode

In Network mode, the board connects to your Wi-Fi and appears in App Lab with a “Network” tag.  It can be hooked up as follows:

As long as the computer is on the same WiFi network as the Uno Q, it should be “seen” by App Lab. You will notice a “Network” connection instead of a “USB” connection on the opening page.

 

You will also need to enter your Linux password to connect. Once connected, you can use the App Lab as if the board was directly connected to your computer,

Conclusion

The Arduino Uno Q is a unique product with significant potential.  While many people are concerned about Qualcomm’s acquisition of Arduino, this board shows that positive things can come from such an arrangement.

In the following article and video, we will learn how to build our own apps. We’ll also hook up some hardware to the boards’ I/O pins and experiment. Hope to see you then!