Credit:

Sign in to your XDA account

Arduino has been a long-beloved producer of microcontrollers and single-board computers, existing in the same realm as the Raspberry Pi but never truly competing against it. Yet the company’s sudden and surprising acquisition by Qualcomm was announced alongside the launch of the Arduino Uno Q, a single-board computer powered by a Qualcomm SoC and running Linux out of the box. It’s the first “true” Raspberry Pi competitor from Arduino, and it’s... weird.

Arduino has had many different products over the years, and this isn’t the company’s first foray outside of microcontrollers; in fact, far from it. The company has launched boards running Linux before, including the Yun and the Tian, yet it’s typically competed more with the likes of the Raspberry Pi Pico and the ESP32.

Here’s the bottom-line: for a first attempt at a true Raspberry Pi experience, the Arduino Uno Q isn’t bad. In fact, it’s capable of some things that no other mainstream board is capable of currently, but those use cases are incredibly niche. With that said, its very existence feels like an attempt to get a product out at the same time as the acquisition and opting to figure out the actual logistics after.

Arduino Uno Q’s hardware is pretty good

Though there are already “open source” concerns

The Arduino Uno Q packs two processing units, and both communicate with eachother via an event-driven serial connection bridge. This is referred to as the “Arduino Bridge” in the documentation, but would more commonly be referred to as a Remote Procedure Call. Essentially, think of this like an actual Arduino Uno bolted onto a Linux computer.

First up, there’s the brains of the operation: the Qualcomm Dragonwing QRB2210. This SoC, if you were to pick a chip in Qualcomm’s portfolio, most closely aligns to the Snapdragon W5+ Gen 1, aimed at smartwatches. It has four Cortex-A53 cores, an Adreno 702 for graphics, dual-channel LPDDR4X RAM support, and support for a display resolution of 720 x 1680. In other words, the Uno Q’s computer half is roughly on par with an entry-level smartphone or an older Raspberry Pi. It’s not a powerhouse, but it gets the job done for lightweight tasks.

Notably, the board includes a 16 GB eMMC for storage (with a 32 GB eMMC, 4 GB RAM model promised in the future), and there’s no SD card support as a result. Networking is built-in, though, with a wireless module providing dual-band Wi-Fi 5 and Bluetooth 5.1 connectivity. This being a Qualcomm platform, there’s also some AI muscle: the QRB2210 includes an AI engine and image signal processors, meaning the Uno Q can handle basic machine vision or audio recognition tasks on-device, and there are several examples given in the Arduino App Lab.

Secondly, there’s the STM32U585 microcontroller acting as the “Arduino” half of the Uno Q. This chip has an Arm Cortex M33 (up to 160 MHz) with 2 MB of flash, 786 KB of SRAM, and a Floating Point Unit for calculations. In raw specs, it’s similar to the microcontroller on the recent Arduino Uno R4, and it’s perfect for real-time, deterministic control loops without interruption. In essence, this microcontroller is responsible for things like reading sensors, driving actuators, and other timing-critical tasks, just like a classic Arduino board would.

The twist with this configuration is that on the Uno Q, this MCU works in tandem with the Linux processor. You can program it with Arduino C++ sketches (in fact, under the hood it runs an Arduino stack built on the Zephyr RTOS, and you can even use the regular old Arduino IDE) and it has direct access to the traditional Arduino Uno R4 headers on the top of the board. That means you can plug in existing Arduino shields or sensors, and the microcontroller handles those I/O pins exactly as an Arduino Uno would. Meanwhile, the Qualcomm chip handles higher-level computation and anything requiring an actual operating system.

This dual-processor setup leads to a peculiar but intriguing hardware design. The Uno Q is physically the same size and shape as an Arduino Uno R4 and even includes the same 14 digital I/O pins and six analog inputs in basically the same layout. It even includes the same 8x13 blue LED matrix and RGB LEDs for visual feedback, plus a Qwiic connector for plugging in I2C modules without soldering. There are also two high-speed connectors on the bottom of the board for more advanced peripherals, and these are for tiny board-to-board connectors, intended to be used with the likes of MIPI CSI cameras, MIPI DSI displays, and analog audio adapters.

In terms of traditional ports on-board, there’s just one... a lone USB-C port. Interestingly, this single USB-C is doing triple duty: it’s used for powering the board, it can act as a USB host (for connecting peripherals), and it even carries video output (DisplayPort alt-mode) to hook up a monitor. The catch is that, since there’s only one port, you’ll almost certainly need a USB-C hub or dongle to use the Uno Q as a little computer. Arduino’s documentation recommends a hub that supports Power Delivery (to power the board) and HDMI output, and I’m using a JSAUX dock that I mostly used with my Steam Deck for that. However, this means that, unlike a Raspberry Pi which has separate HDMI and USB ports, the Uno Q relies on an all-in-one solution.

If you don’t have such a hub, the board is a bit less convenient to hook up, as you can’t just plug in an HDMI monitor directly or attach a USB keyboard without an adapter. It’s a minimalist approach, and one that really highlights how different this device is from a typical Pi.

Open-source concerns are real

And Qualcomm isn’t helping matters

As exciting as the Uno Q’s hardware is, the context of its birth brought hasn’t been without controversy. When Arduino announced it was joining the Qualcomm family, a sizable chunk of the maker community reacted with, well, understandable concern. Arduino has always been synonymous with open-source hardware and software, from schematics to firmware, and people worried this might change. Really, there’s a fear that a big corporation might erode Arduino’s open ethos or prioritize industry over community. Qualcomm in particular, as a major chipmaker, doesn’t have the best reputation in open-source circles. After all, their chips often rely on opaque firmware blobs and some of their documentation can be hard to obtain without NDAs.

Arduino, to its credit, has been trying its best to quell concerns. The Uno Q’s schematics and design files were available day one, and Arduino’s token “open source is love” slogan is emblazoned on the flap of the Uno Q box, visible when you first open it. It seems Arduino wanted to signal that their commitment to openness remains intact despite the new corporate parent. In fact, the official line has been that nothing changes on the open-source front, and Arduino will retain its independent brand and open-source mission while tapping into Qualcomm’s tech, positioning it as a “best of both worlds” situation.

All of this is supported on the surface, at least when it comes to software. The Uno Q’s Debian Linux OS on the application processor, and the microcontroller side uses an open Apache 2.0-licensed Arduino core based on Zephyr RTOS. The Arduino App Lab’s source code is public currently under the GPL, but it’s for the older 0.2.0 version and while a GitHub repository is promised, it hasn’t been published yet.

The core of the issue isn’t Arduino’s dedication; it’s Qualcomm’s. Having the Uno Q schematics is great, but if you wanted to truly build your own clone or dig into the chip internals, you’d need detailed documentation for the Qualcomm QRB2210 SoC, and those aren’t fully open. Qualcomm did publish a datasheet of sorts, but it’s more of a glossy overview than a comprehensive technical reference. By contrast, Raspberry Pi’s SoCs (from Broadcom) also had historically closed documentation, but over time, the Pi Foundation tried to open up whatever they could. Some worry that if Qualcomm doesn’t actively engage with the open-source community, the Uno Q’s Linux side could suffer from lack of upstream support or long-term updates. On a brighter note, it’’ worth mentioning that Qualcomm has made the QRB2210 available to purchase for anyone, and that level of availability is more than can be said for Broadcom’s chips.

For now, I’m cautiously optimistic, though I’m aware of how new this acquistion is and the fact that things could change in the years to come. With that said, the Uno Q hasn’t betrayed Arduino’s open-source legacy yet, and having more open hardware options in the SBC world is always a good thing.

Using the Arduino Uno Q as a desktop

It’s a bit laggy, but it works

The Uno Q might look like an Arduino, but in use it often feels closer to a Raspberry Pi, albeit one that’s taken a detour through Arduino-land. Out of the box, the board comes with a Debian-based Linux OS preinstalled on the eMMC, and the setup experience was... strange. My first boot experience required me to set a password, and the Arduino App Lab felt pretty barebones. There were no indications that I needed to update, but then restarting the application saw it fail to check for updates and the app was inaccessible. Thankfully, a simple “apt update && apt upgrade” solved the problem, but still, it definitely didn’t feel like a setup process aimed at would-be first-time Linux users.

To get screenshots and SMB shares working, I had to install xfce4-screenshooter and gvfs-backends. Otherwise, pressing print screen raised an error, and clicking the “Network” option in the file browser threw an error telling me that the feature isn’t enabled. Again, these errors weren’t exactly user-friendly, as a new Linux user wouldn’t have known how to deal with either of these problems. However, once everything was updated and installed, I could get around to actually using it.

If you’re having trouble conceptualizing how the entire experience works, think of App Lab as an IDE that operates on both the Linux side and the microcontroller side at the same time. In App Lab, you can write Python code that will run on the Linux processor and C++ code that will run on the microcontroller, all within one project. These two sides aren’t isolated; App Lab provides high-level “Bricks” that allow for your Python code to speak to your Arduino code, and vice versa. For example, you could have a Python script doing image processing on the Qualcomm chip, and when it recognizes a particular object, it can trigger a C++ function on the microcontroller to move a robotic arm. The communication happens under the hood via that RPC “bridge” link, so as a developer, you can largely script it in software without fiddling with serial protocols yourself. However, it heavily utilizes Docker, which is a strange choice for a RAM-limited device.

In theory, most of this sounds like a dream for complex projects. In practice, it feels like a bit of a mixed bag. The fact that the Uno Q runs full Linux means you have access to all the usual stuff you’re used to. For example, you can SSH into it, install packages with apt, run Python libraries, and even set it up as a little web server or database host if you want. I’ve already turned it into a music streaming server, and I’ll detail that in a future article. All of this is a huge step up from Arduino’s older Linux attempts, like the Arduino Yun which ran OpenWRT.

The Arduino App Lab itself, being new, isn’t all that frictionless. It tries to simplify hybrid development, but an old-school Raspberry Pi user or experienced microcontroller developer may find it unusual. For example, on most devices, if you want to blink an LED you can often write a quick script toggling a signal on a GPIO pin via a library. On the Uno Q, those same header pins are controlled by the microcontroller (aside from some of the high-speed pins), so you either have to write an Arduino sketch for that blink, or use App Lab’s Python-to-MCU bridge to blink it. App Lab makes that possible (and even easy, in demos), but it does enforce a certain structure. It’s not a Linux board where you run any script, rather a coordinated dance of sorts between high-level Python scripts running on Linux alongside low-level C++ microcontroller code.

It’s a fun device, but it’s certainly rough around the edges. Those Docker containers can get pretty heavy, and with the Qualcomm CPU only being so powerful to a point, it wasn’t long before it felt incredibly sluggish. Deploying new applications is one it really struggles with, and the same goes for running them. I tried the image classification AI example, and while it certainly worked, the QRB2210 chugged. It’s certainly impressive that a $44 board is handling computer vision tasks and even voice recognition on-device while simultaneously blinking LEDs and reading sensors, but you can tell that the Uno Q is really being pushed to its limits. 2 GB of RAM is clearly a bottleneck here, so I recommend running it this particular model as a separate board rather than as a computer from a USB-C hub.

One notable quirk in the current software is power management. Because the microcontroller and main processor are so tightly linked, you can’t really run one without the other. In my tests, even if I issued a shutdown command in Linux, the board would power off for a moment and then the STM32 MCU would just boot Linux right back up again. This means you can’t, say, use the Uno Q as an ultra-low-power standalone MCU by disabling the application processor. It also means that power usage is measured in watts, even at idle, rather than the tiny amounts of power an Uno would be expected to draw. For most, this isn’t a deal-breaker (after all, why would you buy this if you didn’t intend to use the four-core Qualcomm chip?) but it’s still something to be aware of.

The Arduino Uno Q is a confused competitor that’s easy to love

It’s something unique

Being honest, after spending time with the Arduino Uno Q, I keep coming back to the word “weird” as the best descriptive term that I can give it. It’s not the most practical or powerful Linux board by a long shot, and it’s also overkill if you just wanted a simple microcontroller. It sits in a strange limbo between two worlds. And yet, I can’t help but love it for what it is. Arduino strayed into the Raspberry Pi world with the Uno Q, and while the result comes across somewhat confused, it’s also fascinating. In a single $44 device, I can do both low-level hardware hacking and high-level Python scripting, and bridge those gaps where necessary to build something unique and weird.

The Uno Q comes across confused in the sense that it’s trying to be a jack of two trades, and it doesn’t fully match the polish of either dedicated solution. Yet the experience is also somewhat nostalgic; tinkering with it sparks a lot of different ideas, as the hardware layout is unique compared to most single-board computers out there. I appreciate that Arduino and Qualcomm are putting effort into something new rather than just churning out yet another generic Uno successor, even if the Uno Q feels like it probably shouldn’t be under the Uno line in the first place.

This board may not dethrone the Raspberry Pi for mainstream projects (nor would I recommend it as one’s first SBC), but it’s an excellent next step for the many Arduino users who have hit the ceiling of what their current Arduino can do, while not totally abandoning what they know and are used to. I do hope this isn’t a one-and-done experiment by Arduino and Qualcomm, because having more players in the SBC game will drive innovation and as a first product, it’s not bad at all.

Is the Arduino Uno Q a Raspberry Pi competitor? I mean... kind of? It definitely plays by different rules, but it’s very much an Arduino product, through and through. It’s a confused mash-up, but honestly, the most interesting devices are arguably the ones that don’t neatly fit into a single box. I’m sure both companies will iron out the kinks over time, and I’m cautiously optimistic regarding the future of Arduino and what’s going to come next.