Edge AI Development with Arduino UNO Q: Implementation Steps and Verification Points for Object Detection Demo | NEXTY Electronics, Electronic Components and Semiconductor Trading Company

The Arduino UNO Q is a development board that integrates a Linux execution environment using the Qualcomm Dragonwing QRB2210 and microcontroller control using the STM32U585 onto a single board.

This article demonstrates object detection using a USB camera on an Arduino UNO Q, explaining the process from environment setup and Arduino Cloud integration to AI model deployment and detection verification via logs, all based on actual device testing. It also outlines key points to consider during implementation, aimed at engineers at manufacturers who want to quickly set up an edge AI environment for initial evaluation or proof-of-concept (PoC).

Basics of Arduino UNO Q

The Arduino UNO Q is an edge AI-enabled microcontroller board that combines the ease of use of traditional Arduino with the performance of a small computer running Linux, featuring a Qualcomm Dragonwing QRB2210 MPU and an STM32U585 MCU. This palm-sized computer is used in a wide range of applications, including education, prototyping, and IoT.

Furthermore, the Arduino ecosystem has a large user base, making it easy to access sample code and forum information, which is another advantage as it facilitates information gathering during initial evaluation.

Key Features of Arduino UNO Q

This document summarizes the main features of the Arduino UNO Q from the perspectives of processing performance, control performance, development environment, expandability, and usage.

MPU: Equipped with Qualcomm's "Dragonwing QRB2210". It runs a fully functional Linux (Debian) and performs complex calculations and AI processing using Python.
MCU side: Equipped with an STM32U585, it is responsible for processing that requires low latency, such as sensor input and motor control.
Arduino App Lab: Arduino App Lab makes it easier to develop applications that combine sketches, Python scripts, and AI models.
The Arduino UNO Q inherits the form factor and pin configuration used in the Arduino UNO R3/R4. Therefore, you can explore expanding its functionality while leveraging your existing Arduino assets.
The Arduino UNO Q supports both "standalone mode," which allows it to be used like a Linux PC, and "PC connected mode," which allows development and control from the Arduino App Lab on a PC. This allows you to flexibly choose the evaluation environment according to your application.

Object detection demo overview and system configuration

In this verification, we performed an object detection demo using a USB camera on an Arduino UNO Q, referencing publicly available sample applications.

<Reference URL>
https://github.com/robby-proj/robby-project/blob/main/dog-detect-AI/camera-detect/README.md

The referenced document contains information about the application overview, required equipment, and program structure.

On the other hand, there are settings and runtime checkpoints that are difficult to grasp from README.md alone when actually running the program.

Therefore, in this article, we have reviewed the README.md file, source code, configuration files, and information from the Arduino Forum, and compiled the steps and points to note for getting it to work on a real device.

Please note that all of these tests were conducted using the Arduino UNO Q in standalone mode.

Sample App Overview

This sample application is a system that detects people and dogs from video footage from a USB camera and sends the detection results to the Arduino Cloud.

This retrieves video FRAMES from a USB camera.
The TFLite SSD model is used to detect objects from acquired image FRAMES.
From the detection results, we will extract data targeting "person" and "dog".
The detection results will be sent to the Arduino Cloud, allowing you to check the status on the cloud.
The system compiles the detection times and outputs a report showing the detection times for both people and dogs.

Furthermore, upon examining the source code and configuration files, it becomes clear that the process from camera input to cloud transmission follows the following flow:

① Input video from the USB camera.
② Images are acquired from the video FRAMES by frame.
③ Resize the image to 300x300 pixels to match the inference model.
④ Input the data into the TFLite SSD model and perform object detection inference.
⑤ The detection results include obtaining the class ID and confidence score.
⑥ Only results with a class ID of "person" or "dog" and a score greater than 0.55 will be included in the detection process.
⑦ Based on the detection results, the system determines whether a person has been detected, a dog has been detected, or no detection has occurred.
⑧ To reduce continuous notifications, a 10-second cooldown period will be implemented.
⑨ The judgment result is sent to Arduino Cloud.
⑩ The program aggregates detection times every 6 hours and outputs a report. The following is an example of the output.

report ( person detected: 1.2 hours, dog detected: 4.6 hours )

Equipment used

Arduino UNO Q 4GB model
USB HD camera
USB Type-C Hub
Internet connection (Wi-Fi or wired)
USB PD compatible POWER SUPPLIES (5V/3A recommended)
External monitor and HDMI CABLES for use in standalone mode
USB mouse, USB KEY BOARD

Advance preparation

Connect a USB Type-C hub to the Arduino UNO Q, and then connect POWER SUPPLIES, USB mouse, USB KEY BOARD, and USB camera. Connect an external monitor via an HDMI CABLES and boot up in standalone mode.

Image illustrating the connection between Arduino UNO Q and peripheral devices.

Arduino Cloud Setup

Access to the official Arduino website (https://www.arduino.cc/) and register or log in to an account from "Arduino Cloud".

After logging in, click "Things" in the left-hand menu.

Click the "+ THING" button to create a new Thing.

We will register the variables used in the sample application to the Thing we created.

Variable: person_detected , type : Boolean , Permission: Read & Write
Variable: dog_detected , type : Boolean , Permission: Read & Write
Variable: last_label , type : String , Permission: Read & Write
Variable: last_score , type : Float , Permission: Read & Write
Variable: last_ts , type : Integer , Permission: Read & Write

If the registered variables are displayed in the list as shown in the post-configuration screen below, the setup is complete.

Next, obtain the necessary files for the sample application from GitHub and save them to the working directory on your Arduino UNO Q.

The required files are app.py, Dockerfile, docker-compose.yml, and requirements.txt, all located in the camera-detect folder.

https://github.com/robby-proj/robby-project/tree/main/dog-detect-AI/camera-detect

Register your device by following the "Set up Arduino Cloud" section of the official Arduino documentation (https://docs.arduino.cc/tutorials/UNO-q/arduino-cloud/). Note down the device_id and secret_key displayed during registration, as you will need them for subsequent settings.

Set the obtained device_id and secret_key as environment variables in docker-compose.yml (ARDUINO_DEVICE_ID: "YOUR_DEVICE_ID" and ARDUINO_SECRET_KEY: "YOUR_SECRET_KEY"). Note that the secret_key contains authentication information, so do not expose it externally.

AI model preparation

Next, we will download the AI model to be used for object detection.

Navigate to your working directory and create a `models` directory for saving your models.

cd ~/camera-detect
mkdir -p models
cd models

Download the object detection model in TFLite format from the models directory. Execute the command on a single line without line breaks.

wget https://storage.googleapis.com/download.tensorflow.org/models/tflite/coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip

Extract the downloaded ZIP file.

unzip coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip

Verify that detect.tflite has been created using the following command.

ls -la

To convert the class IDs of the inference results into names, download the COCO label file using the following command. If the head command displays labels such as person, bicycle, car, and motorcycle, then the label file has been successfully obtained. This completes the preparation before execution.

# Download COCO labels
wget -O labels.txt https://raw.githubusercontent.com/google-coral/test_data/master/coco_labels.txt

# Verify
head -n 20 labels.txt

Execution steps

Build the container and start it in the background using the following command. Please enter `--build` with two hyphens.

docker compose up -d --build

The sample program generates a report of the detection time every 6 hours after execution. If you want to check the operation sooner, use the log checking method described in the next chapter.

Execution result: Human detection confirmed from logs.

Since the sample program generates reports every 6 hours, during the initial operation check, you should check the logs to confirm that the inference results are being output sequentially.
With the sample program running, execute the following command from another terminal.

docker logs -f camdetect

After executing the command, the container logs will be displayed in real time.

In the following diagram, the output "DETECTED: person score=0.551" confirms that a person was detected in the log.

Furthermore, outputs such as "DETECTION: 86 0.41 → vase" and "DETECTION: 73 0.21 → book" can be observed, indicating that the model is outputting inference results for multiple classes.

Points to check during implementation

The main points we checked during implementation are summarized below.

Since it can be difficult to understand the processing flow from README.md alone, it is important to check the source code and configuration files to understand the data flow from camera input to cloud transmission.
For information on connecting peripherals in standalone mode, please refer to resources such as the Arduino Forum.
By modifying the docker-compose.yml file or the application's settings, it's also possible to add classes other than person and dog to the detection targets.

Comparison of Qualcomm-powered Arduino products

Lineup of Arduino products equipped with Qualcomm chips

As of this announcement, there are two Arduino products equipped with Qualcomm chips: the Arduino UNO Q and the Arduino Ventuno Q.

A comparison of the main specifications of Arduino UNO Q and Arduino Ventuno Q.

	Arduino UNO Q	Arduino Ventuno Q
MPU used	Qualcomm Dragonwing™ QRB2210： CPU: Quad-core Arm® Cortex®-A53 @ 2.0 GHz GPU: Qualcomm Adreno GPU 3D graphics accelerator 2x ISP (13 MP + 13 MP or 25 MP) @ 30 fps	Qualcomm Dragonwing™ IQ8 QCS8275： CPU: Octa-core Qualcomm® Kryo™ @ Up to 2.35 GHz GPU: Qualcomm Adreno 623 at 877 MHz Hexagon Tensor AI Processor (NPU): up to 40 Dense TOPS Qualcomm Spectra 692 ISP
MCU used	STM32U585： Arm® Cortex®-M33 up to 160MHz 2 MB flash memory 786 KB SRAM	STM32H5F5： Arm® Cortex® M33 at 250MHz 4MB flash 1.5MB RAM
RAM	2GB or 4GB LPDDR4	2x8GB LPDDR5
Storage	16GB or 32GB eMMC	64GB eMMC M.2 connector for NVME Gen.4 external storage
Supported Interfaces	I2C/I3C SPI PWM CAN UART PSSI GPIO JTAG ADC	I2C/I3C SPI PWM UART PSSI GPIO JTAG ADC
Supported OS	Linux Debian Zephyr	Linux Debian Ubuntu Zephyr
External shape	68.85 x 53.34mm	160 x 100 x 25.8 mm

Summary

The Arduino UNO Q is an edge AI-enabled development board that inherits the ease of use of traditional Arduino while providing a Linux operating environment and real-time control on a single board.

In this verification, we conducted an object detection demo using a USB camera on an Arduino UNO Q, confirming the detection of people and dogs, and the process of sending detection results to Arduino Cloud. While implementation required reviewing the README.md, source code, configuration files, and forum information, we were able to confirm that the AI inference application could run even in standalone mode.

Thus, the Arduino UNO Q is a development board suitable not only for educational purposes and prototype development, but also for edge AI verification using camera input and evaluation of IoT cloud integration. It is a strong candidate when you want to quickly launch an initial proof of concept (PoC).