Introduction
Details
Step 1 — Initial Setup and Wi-Fi Connection
Step 2 — Flash the STM32 Microcontroller (The Muscle
Step 3 — Set Up the Web Server on Linux (The Brain
Step 4 — Control It From Your Smartphone

Published June 25, 2026 © GPL3+

Control Arduino UNO Q via Smartphone Web Dashboard

Host a wireless web dashboard on the Arduino UNO Q's Linux side to control the STM32 MCU and view stats from your phone. No PC requi

IntermediateFull instructions provided1 hour4

Control Arduino UNO Q via Smartphone Web Dashboard

Things used in this project

Hardware components

Arduino UNO Q

USB Cable, USB Type C Plug

Samsung smartphone

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

micro:bit python.microbit.org

Story

Introduction

The Official Arduino UNO Q is a powerhouse. Unlike traditional microcontrollers, it features a "dual-brain" architecture: a Qualcomm® Dragonwing™ MPU running Linux Debian for heavy AI/processing tasks, and an STM32U585 MCU for real-time hardware control.

But once you deploy this board in a remote location like a smart garden monitor, a ceiling-mounted AI camera, or a remote weather station plugging in a USB-C cable to check its status or change a setting is a massive hassle.

This project shows you how to bridge the two "brains" to create a wireless smartphone dashboard. You will host a lightweight web server on the Linux side that lets you control the STM32's pins and view real-time hardware feedback directly from your phone's browser. No custom apps to install, no cables needed after setup!

Details

To make this work, the two processors need to talk to each other.

The Linux MPU runs a Python web server that serves a clean HTML dashboard to your smartphone over Wi-Fi.
When you tap a button on your phone, the Python script sends a serial command to the STM32 MCU.
The STM32, which is constantly listening, receives the command and toggles the hardware (like turning on a relay or drawing a pattern on the onboard 8x13 LED matrix).

This setup means your phone acts as the remote control, the Linux MPU acts as the wireless router/web host, and the STM32 acts as the muscle.

Step 1 — Initial Setup and Wi-Fi Connection

Arduino UNO Q SBC plugged into power and an Ethernet/Wi-Fi dongle

First, we need to get the UNO Q connected to your local network.

Connect the Arduino UNO Q to your PC via the USB-C port.
Power it using a 5V 3A USB-C PD adapter (or your PC, though a dedicated adapter is recommended for full SBC performance).
Access the Linux terminal via SSH or the serial console.
Connect to your Wi-Fi using the standard Debian network manager or the Arduino App Lab.
Once connected, type hostname -I in the terminal to find the board's IP address (e.g., 192.168.1.45). Note this down!

Step 2 — Flash the STM32 Microcontroller (The Muscle)

Now we program the real-time MCU to listen for commands from the Linux side.

Open the Arduino IDE on your PC.
Select the Arduino UNO Q (STM32 side) as your board and select the correct COM port.
Upload the following sketch. This code listens to the internal serial port for specific characters (1 to turn on the hardware, 0 to turn it off) and prints a heartbeat message back to the Linux side so you know it's alive.

Step 3 — Set Up the Web Server on Linux (The Brain)

SSH terminal showing the Python server running

Now we move to the Qualcomm MPU side. We will create a simple Python web server using the Flask library.

SSH into your Arduino UNO Q's Linux environment.
Install Flask and PySerial by running: pip3 install flask pyserial
Create a new Python file named dashboard.py and paste the code provided below. This script creates a mobile-friendly web page with "ON" and "OFF" buttons.
Run the script: python3 dashboard.py

Step 4 — Control It From Your Smartphone

web dashboard displayed on a smartphone screen next to the physical Arduino UNO Q

This is the best part—no apps to install, no cables needed!

Make sure your smartphone is connected to the same Wi-Fi network as the Arduino UNO Q.
Open Chrome or Safari on your phone.
Navigate to http://192.168.1.45:5000 (replace with your board's actual IP address).
You will see a clean, mobile-friendly dashboard.
Tap the buttons! You will instantly see the STM32 respond and the onboard hardware toggle.

Pro-Tips for Deployment

Static IP: To avoid typing a new IP address every time, assign a static IP to your UNO Q in your router's DHCP settings.
Expand It: You can easily expand this dashboard to read temperature sensors connected via the Qwiic connector, or even trigger the AI vision models pre-loaded in the Arduino App Lab!
Auto-start: To make the Python dashboard run every time the UNO Q boots, add the python3 /path/to/dashboard.py command to your Linux cron table or systemd services.

/*
 * Arduino UNO Q - STM32 Side Firmware
 * Listens for serial commands from the Linux MPU to control hardware.
 */

char command;

void setup() {
  // Initialize serial communication with the Linux MPU
  Serial.begin(115200); 
  pinMode(LED_BUILTIN, OUTPUT);
  
  // Note: You can expand this to control the 8x13 LED matrix 
  // or Qwiic modules using their respective libraries!
}

void loop() {
  // Listen for commands from the Linux Web Server
  if (Serial.available() > 0) {
    command = Serial.read();
    if (command == '1') {
      digitalWrite(LED_BUILTIN, HIGH);
      Serial.println("STM32: Hardware ON");
    } 
    else if (command == '0') {
      digitalWrite(LED_BUILTIN, LOW);
      Serial.println("STM32: Hardware OFF");
    }
  }
  
  // Send a heartbeat to Linux every 5 seconds so the dashboard knows we are alive
  static unsigned long lastBeat = 0;
  if (millis() - lastBeat > 5000) {
    Serial.println("STM32: Heartbeat OK");
    lastBeat = millis();
  }
}

# Arduino UNO Q - Linux MPU Web Dashboard
from flask import Flask, render_template_string
import serial
import time

# Connect to the STM32 MCU via the internal serial port.
# NOTE: The exact port path (e.g., /dev/ttySTM32, /dev/ttyS1) may vary 
# depending on your specific Debian image. Check your UNO Q documentation.
ser = serial.Serial('/dev/ttySTM32', 115200, timeout=1)
time.sleep(2) # Wait for STM32 to initialize

app = Flask(__name__)

# Clean, mobile-friendly HTML Dashboard for the smartphone
HTML_DASHBOARD = """
<!DOCTYPE html>
<html>
<head>
    <title>UNO Q Dashboard</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <style>
        body { font-family: Arial, text-align: center; margin-top: 50px; background-color: #f4f4f9; }
        .btn { padding: 20px 40px; font-size: 24px; margin: 10px; border: none; border-radius: 8px; cursor: pointer; box-shadow: 0 4px 6px rgba(0,0,0,0.1); }
        .on { background-color: #28a745; color: white; }
        .off { background-color: #dc3545; color: white; }
        h1 { color: #008184; } /* Arduino Teal */
        .status { font-size: 18px; color: #555; margin-top: 20px; font-style: italic; }
    </style>
</head>
<body>
    <h1>Arduino UNO Q Control</h1>
    <p>Dual-Brain Wireless Dashboard</p>
    <form action="/on" method="POST"><button class="btn on">TURN ON</button></form>
    <form action="/off" method="POST"><button class="btn off">TURN OFF</button></form>
    <p class="status"><strong>MCU Status:</strong> {{ status }}</p>
</body>
</html>
"""

status_msg = "Waiting for data..."

@app.route('/')
def index():
    global status_msg
    # Read any pending messages from STM32 (like the heartbeat)
    if ser.in_waiting > 0:
        status_msg = ser.readline().decode('utf-8').strip()
    return render_template_string(HTML_DASHBOARD, status=status_msg)

@app.route('/on', methods=['POST'])
def turn_on():
    ser.write(b'1')
    return "<script>window.location.href='/'</script>"

@app.route('/off', methods=['POST'])
def turn_off():
    ser.write(b'0')
    return "<script>window.location.href='/'</script>"

if __name__ == '__main__':
    # Run on all interfaces (0.0.0.0) so the smartphone can access it over Wi-Fi
    app.run(host='0.0.0.0', port=5000, debug=True)

Credits

Daniel D'Souza

4 projects • 0 followers

Embedded systems & robotics engineer with 9+ yrs in IoT & hardware, building practical projects and hands-on STEM learning

Control Arduino UNO Q via Smartphone Web Dashboard