Arduino VENTUNO Q Guide: Pinout, AI/Robotics Hardware and Expansion

The Arduino VENTUNO Q is not simply a faster UNO Q. It is a much larger edge-AI and robotics platform designed to combine local AI inference, high-bandwidth cameras, fast networking and deterministic real-time control on one board.

At the centre is a Qualcomm Dragonwing IQ8 QCS8275 application processor with an octa-core Kryo CPU, Adreno 623 GPU, Hexagon Tensor AI processor rated at up to 40 dense TOPS, and a Qualcomm Spectra image signal processor. Alongside it is an STM32H5F5 Cortex-M33 microcontroller running at up to 250 MHz for the physical side of the system: GPIO, PWM, CAN-FD, sensors, motor control and other timing-sensitive tasks.

The result is a board that can run a local LLM, process several camera streams, host ROS 2 nodes and communicate over 2.5 Gb Ethernet while a separate real-time MCU controls motors and actuators.

This guide explains the VENTUNO Q architecture, practical pinout, expansion connectors, camera and display interfaces, CAN-FD, Qwiic, NVMe, Raspberry Pi HAT support, power options and how the board fits into AI and robotics projects.

VENTUNO Q Specifications at a Glance

Feature	VENTUNO Q
Application processor	Qualcomm Dragonwing IQ8 QCS8275
CPU	Octa-core Kryo Gen 6
GPU	Adreno 623
AI accelerator	Hexagon Tensor processor, up to 40 dense TOPS
Image processing	Qualcomm Spectra 692/690 ISP subsystem
Real-time MCU	STM32H5F5, Arm Cortex-M33 at up to 250 MHz
MCU Flash	4 MB
MCU RAM	1.5 MB
System RAM	16 GB LPDDR5
Onboard storage	64 GB eMMC
Expandable storage	M.2 NVMe Gen4
Operating system	Ubuntu Linux; Debian support planned
MCU OS	Arduino Core on Zephyr
Wireless	Wi-Fi 6 on 2.4/5/6 GHz bands, Bluetooth 5.3
Ethernet	2.5 Gbit/s RJ45
USB	USB-C host/device + video, 2× USB 3.0 Type-A, 2× USB 3.0 on JOMEGA
Camera	3× onboard MIPI CSI, plus MIPI CSI through JMEDIA
Display	HDMI, USB-C DisplayPort Alt Mode, MIPI DSI through JMEDIA
CAN	CAN-FD with onboard PHY on screw terminal, plus additional logic-level CAN-FD interfaces
Arduino expansion	UNO shield headers + Qwiic
SBC expansion	40-pin Raspberry Pi HAT-style header
High-density expansion	JMEDIA, JMISC and 100-pin JOMEGA
Dimensions	160 × 100 × 25.8 mm

Dual-Brain Architecture

VENTUNO Q follows the same broad philosophy as UNO Q but scales it much further.


Qualcomm Dragonwing IQ8
Ubuntu Linux
AI / vision / ROS 2 / networking / storage
LLMs / Python / containers / user interfaces
                  │
                  │ Bridge / RPC
                  ▼
STM32H5F5
Arduino Core on Zephyr
GPIO / PWM / ADC / CAN-FD / I2C / SPI
motors / encoders / sensors / safety logic

Qualcomm Dragonwing IQ8

Ubuntu Linux

AI / vision / ROS 2 / networking / storage

LLMs / Python / containers / user interfaces

│

│ Bridge / RPC

▼

STM32H5F5

Arduino Core on Zephyr

GPIO / PWM / ADC / CAN-FD / I2C / SPI

motors / encoders / sensors / safety logic

The Linux processor deals with high-level computation. The STM32H5F5 deals with deterministic interaction with the physical world.

This split matters in robotics. A Linux process can be busy running visual SLAM or a vision-language model without being responsible for generating every motor pulse or reacting to an emergency input at exactly the right time.

Qualcomm Dragonwing IQ8: The AI Brain

The Dragonwing IQ8 QCS8275 is the reason VENTUNO Q belongs in a different class from conventional Arduino boards.

Its main resources include:

octa-core Kryo Gen 6 CPU;
Adreno 623 GPU;
Hexagon Tensor AI processor;
up to 40 dense TOPS of NPU acceleration;
Qualcomm Spectra image-processing hardware;
high-bandwidth LPDDR5 memory.

That combination is intended for workloads such as:

object detection;
visual SLAM;
multi-camera robotics;
local language models;
vision-language models;
speech recognition;
gesture recognition;
predictive maintenance;
machine inspection;
multimodal AI.

The important part is that these workloads can run locally rather than sending every camera frame or audio sample to a cloud server.

STM32H5F5: The Real-Time Action Brain

The second processor is an STM32H5F5 with an Arm Cortex-M33 core running at up to 250 MHz.

It provides:

4 MB Flash;
1.5 MB RAM;
Arduino Core on Zephyr;
low-latency GPIO;
PWM and timer control;
CAN-FD;
I2C/I3C;
SPI;
UART;
real-time interaction with sensors and actuators.

This is not a token secondary MCU. It is powerful enough to operate as a serious embedded controller while the Dragonwing processor handles the AI workload.

VENTUNO Q Pinout Philosophy

The VENTUNO Q has several different expansion layers rather than one simple row of GPIO.

It is easiest to think of the board as having six connector families:

UNO shield headers for familiar Arduino prototyping.
Qwiic for plug-and-play I2C sensors.
40-pin HAT header for Raspberry Pi-style expansion.
JMEDIA and JMISC for cameras, displays and audio.
JOMEGA for high-density robotics and system expansion.
Dedicated connectors for Ethernet, USB, HDMI, M.2, MIPI cameras, CAN-FD and power.

This layered design is important. You can use VENTUNO Q like an Arduino with shields, like an SBC with USB and HDMI, or like an embedded compute module with high-density connectors.

UNO Shield Headers

The board retains Arduino UNO-style headers, giving it immediate compatibility with a large ecosystem of shields and breadboard wiring.

The familiar Arduino labels include:

D0 to D21 digital positions;
A0 to A5 analog positions;
UART functions;
SPI;
I2C;
PWM-capable outputs;
CAN-FD controller signals;
power and reference connections.

For ordinary Arduino code, you normally work with the Arduino pin names rather than the raw STM32H5 package pin names:


pinMode(D3, OUTPUT);
digitalWrite(D3, HIGH);

int value = analogRead(A0);

pinMode(D3, OUTPUT);

digitalWrite(D3, HIGH);

int value = analogRead(A0);

This is intentionally familiar to developers coming from UNO R4, UNO Q and older Arduino boards.

UART on the UNO Header

The standard Arduino serial positions retain the familiar convention:

Function	Arduino position
UART RX	D0
UART TX	D1

This allows modules such as GNSS receivers, serial motor controllers and industrial interfaces to be connected in the normal Arduino style.

Remember that the board is a modern 3.3 V platform. Do not assume that a legacy 5 V serial device can be connected safely without checking its I/O levels.

SPI on the UNO Header

The standard UNO SPI positions use the familiar Arduino layout:

Signal	Arduino position
Chip select	D10
MOSI / COPI	D11
MISO / CIPO	D12
SCK	D13

This keeps many SPI displays, ADCs, radio modules and expansion shields straightforward to reuse.

I2C and Qwiic

VENTUNO Q provides conventional Arduino I2C access as well as an onboard Qwiic connector.

The classic Arduino I2C positions are:

Signal	Arduino position
SDA	D20
SCL	D21

The dedicated Qwiic connector supplies 3.3 V I2C for compatible sensors and Modulino nodes.

This is useful for robotics because a complete sensor chain can be added without consuming the main expansion headers:

IMU;
distance sensor;
temperature/humidity sensor;
light sensor;
environmental sensor;
Qwiic motor or actuator module.

Analog Inputs

The familiar A0 to A5 positions provide the normal Arduino-style analog interface for potentiometers, analog sensors and conditioning circuits.

Because VENTUNO Q uses a modern STM32 microcontroller and a 3.3 V logic environment, do not treat the analog inputs like the 5 V ADC inputs of an old UNO R3.

Always check the full pinout and the STM32H5 electrical limits before applying an external analog voltage.

PWM and Motor Control

PWM is central to the VENTUNO Q design because the board is intended for robotics and actuation.

PWM-capable MCU outputs can be used for:

motor drivers;
servo control;
LED dimming;
fan control;
power converters;
solenoids and valves;
robotic joint controllers.

For serious motors, the GPIO pins do not drive the motor directly. They control an external motor driver, inverter, servo drive or H-bridge.

The high-density JOMEGA connector is particularly relevant for robotics because it exposes additional MCU and system signals beyond the normal UNO header.

CAN-FD: One of the Most Important Robotics Interfaces

VENTUNO Q includes unusually strong CAN support.

Arduino specifies:

1× CAN-FD interface with an onboard physical transceiver exposed on a screw terminal;
3× additional CAN-FD controller interfaces on JOMEGA without onboard PHYs;
1× CAN-FD controller interface on the UNO shield headers without an onboard PHY.

This distinction matters.

The screw-terminal CAN-FD connection is designed for connection to a real CAN bus because the transceiver is already onboard.

The logic-level CAN-FD interfaces on JOMEGA and the UNO headers still require suitable external CAN transceivers before connecting to CANH and CANL.

This makes VENTUNO Q particularly suitable for:

robot joint networks;
AGVs and AMRs;
automotive development;
industrial machines;
distributed motor drives;
CAN-based sensor networks.

2.5 Gbit Ethernet

VENTUNO Q includes a native 2.5 Gbit/s RJ45 Ethernet port.

This is a major advantage for machine vision and industrial edge computing because cameras and AI systems can generate far more data than ordinary sensor nodes.

Fast wired networking is useful for:

streaming video;
transferring training or inspection datasets;
ROS 2 networks;
industrial gateways;
remote development;
large model deployment;
network-attached storage;
multi-robot systems.

Wi-Fi 6 and Bluetooth 5.3

The board also includes onboard wireless connectivity:

Wi-Fi 6 across the supported 2.4, 5 and 6 GHz bands;
Bluetooth 5.3;
onboard antenna.

For fixed robots or industrial systems, Ethernet may be preferable. For mobile robots, drones and development work, onboard wireless avoids adding another networking module.

Three MIPI CSI Camera Connectors

Computer vision is one of the defining features of VENTUNO Q.

The board includes three dedicated MIPI CSI camera connectors. These high-speed camera inputs are much more appropriate for serious vision systems than low-speed SPI camera modules.

The camera interfaces can be used for applications such as:

front/rear/side robot vision;
stereo depth;
360-degree perception;
visual SLAM;
quality inspection;
gesture recognition;
tracking;
autonomous navigation.

Arduino also exposes additional MIPI CSI connectivity through JMEDIA, with some camera resources multiplexed between the onboard connectors and the high-density expansion path.

That means the full pinout should always be checked when designing a custom carrier that uses the MIPI lanes.

USB Cameras

You are not restricted to MIPI cameras.

VENTUNO Q can also use USB cameras through its USB host ports. For rapid prototyping, this is often the easiest route because Linux exposes a supported UVC camera through the normal video device interface.

A USB camera is particularly convenient for testing AI models before designing a final MIPI camera solution.

HDMI Output

Unlike UNO Q, VENTUNO Q has a dedicated HDMI connector.

This makes standalone SBC operation straightforward:

connect an HDMI display;
connect a keyboard and mouse to the USB-A ports;
power the board from an appropriate supply;
boot Ubuntu;
run Arduino App Lab directly on the board.

The HDMI path is multiplexed with MIPI DSI resources, so advanced custom display designs should refer to the board pinout before using both interfaces.

USB-C DisplayPort Output

The USB-C connector also supports video output using DisplayPort Alt Mode.

This gives the board two practical display routes:

dedicated HDMI;
DisplayPort over USB-C.

A USB-C hub can also combine video with additional USB and networking peripherals.

JMEDIA Connector

JMEDIA is the high-speed multimedia expansion connector.

It carries interfaces associated with:

MIPI CSI camera signals;
MIPI DSI display signals;
high-speed multimedia functions;
camera/display control buses.

This connector is intended for carrier boards and custom hardware rather than breadboard wires.

The Arduino UNO Media Carrier ecosystem demonstrates the type of expansion possible through the JMEDIA/JMISC architecture, including MIPI cameras, MIPI displays and audio.

JMISC Connector

JMISC carries additional system and multimedia signals that do not belong on the normal UNO headers.

Arduino documents audio capabilities through this expansion area including:

microphone input;
headphone output;
earpiece output;
line output.

For a production robot, kiosk or voice interface, JMISC makes it possible to build a custom carrier rather than relying permanently on USB audio adapters.

JOMEGA: The 100-Pin Expansion Connector

JOMEGA is the major high-density system connector on VENTUNO Q.

It is a 100-pin expansion interface that exposes a much larger set of system resources than the UNO headers.

Functions available through JOMEGA include categories such as:

additional CAN-FD;
USB 3.0;
GPIO;
PWM;
UART;
I2C/I3C;
SPI;
debug/JTAG;
system power rails;
control and reset signals.

For a custom robot controller or industrial carrier, JOMEGA is arguably the most important connector on the board.

It lets the VENTUNO Q act as the central compute module while a custom baseboard provides motor drivers, power electronics, isolated I/O, industrial connectors and field interfaces.

40-Pin Raspberry Pi HAT-Compatible Header

VENTUNO Q also includes a 40-pin header intended to access the wider Raspberry Pi HAT ecosystem.

This is a useful bridge between Arduino and SBC hardware because many existing accessories are built around the 40-pin Raspberry Pi mechanical layout.

However, mechanical compatibility does not guarantee software or electrical compatibility.

Before using a HAT, verify:

logic voltage;
required power rails;
expected Linux drivers;
GPIO numbering;
I2C/SPI bus assignment;
interrupt requirements;
whether the HAT assumes Raspberry Pi-specific hardware.

M.2 NVMe Gen4 Storage

VENTUNO Q includes an M.2 connector for NVMe Gen4 storage expansion.

This is an unusually important feature for edge AI because 64 GB of onboard eMMC can become small surprisingly quickly when storing:

large language models;
vision models;
camera recordings;
training datasets;
ROS 2 bag files;
production inspection images;
database history.

An NVMe SSD turns the board into a much more capable local data-processing platform.

USB 3.0 Expansion

VENTUNO Q has:

2× USB 3.0 Type-A connectors;
USB-C with host/device role switching;
2× additional USB 3.0 interfaces exposed through JOMEGA.

Possible peripherals include:

USB cameras;
LiDAR adapters;
storage devices;
microphones;
speakers;
keyboards and mice;
serial adapters;
specialised measurement equipment.

Onboard LED Matrix and RGB LEDs

The board includes an 8 × 13 blue LED matrix plus four user-controllable RGB LEDs.

The matrix is useful for:

boot status;
robot state;
AI inference status;
diagnostic codes;
simple animations;
headless feedback.

On a board this complex, having visible status output before a display or network session is available can be surprisingly useful.

Power Inputs

VENTUNO Q has significantly higher power requirements than a normal Arduino.

Current Arduino setup documentation supports:

7–24 V DC through the external power input;
7–24 V through the screw-terminal power connection;
USB-C Power Delivery with appropriate negotiated voltage;
7–24 V through JOMEGA for integrated carrier designs.

Arduino recommends a robust external supply for heavy AI and USB workloads. A normal 5 V PC USB port should not be treated as the board’s primary power source.

For standalone SBC setup, Arduino recommends its 65 W USB-C power supply or an appropriately rated DC supply.

Why Power Matters More on VENTUNO Q

Power consumption can rise quickly when the board is simultaneously using:

NPU inference;
GPU processing;
multiple cameras;
NVMe storage;
USB peripherals;
Ethernet;
external displays;
motor-control electronics.

Brownouts that would never appear on a simple MCU board become a genuine design concern.

For robots, it is good practice to separate noisy motor power from the computing rails and design grounding, DC/DC conversion and transient suppression properly.

Running Ubuntu

VENTUNO Q currently runs Ubuntu Linux on the Dragonwing processor. Arduino’s published image is based on Ubuntu 24.04.

This makes the board immediately familiar to Linux developers:


sudo apt update
sudo apt upgrade

sudo apt update

sudo apt upgrade

Standard Linux development tools, Python, containers and packages can be used directly.

Arduino also states that Debian support is planned, but current VENTUNO Q documentation is centred on Ubuntu.

Arduino App Lab

Arduino App Lab is the unified environment for projects that combine the Linux processor and the STM32 microcontroller.

An App can contain:

Python code;
Arduino sketches;
containerised Linux services;
AI Bricks;
Bridge/RPC communication between the MPU and MCU.

If you have not used this architecture before, see our Arduino App Lab and Bridge/RPC guide. The same basic split between Linux and real-time MCU applies to VENTUNO Q.

Local LLMs

VENTUNO Q has enough memory and AI acceleration to run local language models that would be unrealistic on a normal microcontroller platform.

Arduino’s current examples include local models from families such as:

Qwen;
Gemma;
Whisper for speech recognition;
text-to-speech engines;
YOLO-style object detection;
MediaPipe gesture recognition.

Arduino demonstrates LLM execution through both the Adreno GPU and the Hexagon NPU.

This enables applications that remain functional without a cloud AI service.

Why the NPU Matters

A general-purpose CPU can execute neural networks, but it is rarely the most efficient way to run them continuously.

The Hexagon NPU is designed specifically for tensor operations used by modern neural networks.

Offloading inference to the NPU can:

reduce CPU load;
increase inference speed;
leave CPU resources available for ROS 2 and networking;
improve efficiency for continuous AI workloads.

This is particularly important in robots where perception must run constantly while the rest of the software stack remains responsive.

ROS 2 on VENTUNO Q

VENTUNO Q can run ROS 2 Jazzy natively on Ubuntu.

This makes it a strong platform for:

mobile robots;
robotic arms;
autonomous vehicles;
camera-based navigation;
multi-sensor fusion;
distributed robot systems.

A typical architecture might be:


ROS 2 on Dragonwing IQ8
├── camera nodes
├── SLAM
├── object detection
├── navigation
├── planning
└── network interfaces
        │
        ▼
Bridge / RPC
        │
STM32H5F5
├── encoder capture
├── PWM
├── CAN-FD
├── motor control
├── limit switches
└── local safety logic

ROS 2 on Dragonwing IQ8

├── camera nodes

├── SLAM

├── object detection

├── navigation

├── planning

└── network interfaces

│

▼

Bridge / RPC

│

STM32H5F5

├── encoder capture

├── PWM

├── CAN-FD

├── motor control

├── limit switches

└── local safety logic

Three-Camera Robot Example

One obvious use of the VENTUNO Q hardware is a mobile robot with multiple cameras.

For example:

front camera for object detection;
left/right cameras for wide-angle navigation;
2.5 Gb Ethernet for connection to a development workstation;
NVMe for ROS bag recording;
CAN-FD to motor controllers;
STM32H5 for encoder and safety handling;
NPU for local vision inference.

This would normally require an SBC, a separate MCU, a network adapter, storage expansion and several carrier boards. VENTUNO Q is specifically designed to consolidate that type of system.

Industrial Vision Example

A production inspection system could use:

MIPI CSI camera for high-quality input;
NPU object or defect detection;
2.5 Gb Ethernet for production-network integration;
NVMe for rejected-image storage;
STM32 real-time trigger input;
CAN-FD or digital outputs to the PLC/machine interface;
HDMI display for operator feedback.

The board can therefore make an AI decision and act on the machine without sending images to a remote data centre.

Offline Voice Assistant Example

Arduino also demonstrates a completely local voice-assistant workflow.

The pipeline can include:


Microphone
    ↓
wake-word model
    ↓
speech recognition
    ↓
local LLM
    ↓
text-to-speech
    ↓
speaker

Microphone

↓

wake-word model

↓

speech recognition

↓

local LLM

↓

text-to-speech

↓

speaker

Because the processing can remain on the board, the application can operate without continuously uploading microphone audio to a cloud service.

VENTUNO Q as a Standalone Computer

VENTUNO Q can operate directly as an SBC.

Connect:

HDMI display;
USB keyboard;
USB mouse;
appropriate external power.

Ubuntu and Arduino App Lab can then run directly on the board.

This is useful for development benches, classrooms and demonstrations because no separate host PC is required.

Headless Operation

For an installed robot or industrial system, the board can run headless.

Typical access methods include:

SSH over Ethernet or Wi-Fi;
ADB during setup and recovery;
Arduino App Lab network mode;
ROS 2 network tools.

The onboard LED matrix and RGB LEDs remain useful for local diagnostic feedback when there is no display attached.

VENTUNO Q vs a Conventional Arduino

VENTUNO Q still supports familiar Arduino concepts, but it should not be approached as a giant replacement for an UNO R4.

If your project only needs:

a few sensors;
some PWM outputs;
Wi-Fi;
basic automation;

then VENTUNO Q is unnecessary.

Its value appears when you simultaneously need several of the following:

local AI;
multiple cameras;
ROS 2;
very fast networking;
large RAM;
large local storage;
NVMe;
CAN-FD;
deterministic motor control;
Linux software;
complex user interfaces.

VENTUNO Q and UNO Q

The two boards share the dual-brain Arduino philosophy but target different scales of project.

UNO Q remains compact, relatively approachable and well suited to advanced makers, smaller robots and Linux-plus-Arduino projects.

VENTUNO Q dramatically increases:

AI performance;
RAM;
storage;
camera count;
network speed;
USB expansion;
CAN-FD capacity;
robotics-focused connectivity.

Our UNO Q pinout guide explains the smaller board’s architecture in detail.

Important Expansion Warnings

VENTUNO Q exposes several voltage domains and high-speed interfaces. Do not treat every pin as generic 3.3 V GPIO.

In particular:

verify logic voltage before using old 5 V shields;
do not connect raw CAN controller pins directly to CANH/CANL unless that interface includes a PHY;
do not breadboard MIPI CSI/DSI high-speed lanes;
check multiplexed camera/display resources before designing a carrier;
use the official pinout for JOMEGA, JMEDIA and JMISC connections;
do not power motors directly from MCU pins;
design adequate power conversion for cameras, NVMe, USB and motor-control hardware.

Which Connector Should You Use?

Requirement	Best starting interface
Normal Arduino shield	UNO headers
Qwiic / Modulino sensor	Qwiic
Simple SPI peripheral	UNO SPI pins
Simple I2C peripheral	D20/D21 or Qwiic
Real CAN-FD bus	CAN-FD screw terminal with onboard PHY
Additional CAN-FD channels	JOMEGA + external transceiver
MIPI camera	Dedicated CSI connector
Custom MIPI carrier	JMEDIA
Audio carrier	JMISC
Custom robot baseboard	JOMEGA
Raspberry Pi accessory	40-pin HAT-style header, after compatibility checks
Fast local storage	M.2 NVMe
External display	HDMI or USB-C DisplayPort
USB camera/peripheral	USB-A
High-speed network	2.5 Gb Ethernet

Who Is VENTUNO Q For?

VENTUNO Q makes the most sense for developers building:

autonomous mobile robots;
robotic arms;
multi-camera vision systems;
AI inspection machines;
industrial edge gateways;
local LLM appliances;
voice assistants;
smart-city vision nodes;
research platforms;
ROS 2 systems;
physical-AI demonstrations;
advanced education labs.

Final Thoughts

The Arduino VENTUNO Q is best understood as a robotics and physical-AI computer with an Arduino real-time control layer.

The Qualcomm Dragonwing IQ8 provides the compute resources required for modern AI workloads: an octa-core CPU, Adreno GPU, Hexagon NPU delivering up to 40 dense TOPS and image-processing hardware. The 16 GB of LPDDR5 and 64 GB eMMC give Linux enough space to run serious applications, while M.2 NVMe makes large datasets and model storage practical.

The STM32H5F5 gives the system something an ordinary AI SBC does not have by default: a dedicated 250 MHz Cortex-M33 MCU for deterministic control.

The expansion system is equally important. UNO shields and Qwiic keep basic prototyping approachable, while triple MIPI CSI, HDMI, DisplayPort, 2.5 Gb Ethernet, USB 3.0, NVMe, multiple CAN-FD interfaces, JMEDIA, JMISC, JOMEGA and the 40-pin HAT header allow the board to scale into far more complex machines.

For simple Arduino projects it is massive overkill. For a robot that must see, reason and physically react in real time, that is exactly the point.