Published by Tishin at January 22, 2026

Controlling the Arduino Uno Q with Python

Q: How does Python on the Qualcomm Linux MPU communicate with the STM32 MCU on the Arduino Uno Q?

The Arduino Uno Q runs an internal Arduino_RouterBridge daemon that routes Remote Procedure Calls (RPC) over a high-speed internal serial bus. When a Python script on the Qualcomm Linux MPU invokes a command (such as board.digital_write(pin, HIGH) or board.analog_read(pin)), the call is serialized into a lightweight binary packet, transmitted to the STM32 real-time coprocessor, and executed at deterministic hardware speeds.

Q: How do you prevent high-frequency Python sensor polling from saturating the internal RPC link?

Polling RPC calls inside an unconstrained while True loop can flood the internal UART buffer and spike CPU usage. Always introduce non-blocking event delays using time.sleep(0.01) (10ms) or subscribe to asynchronous event callbacks provided by the bridge library so the STM32 only pushes data packets when sensor thresholds change.

BY Tishin Padilla | PUBLISHED JANUARY 21, 2026

If you’ve been following the build for the VTM Desk Bot, you know the goal isn't to create a single-task toy. The vision for this Arduino Uno Q project is a versatile robot that actually helps you build—a companion that can grow and take on more complex jobs as the system expands.

Component	Architecture	System Role
MPU (Brain)	Qualcomm QRB2210	Linux OS, Python Environment, SLM Processing
MCU (Body)	STM32U585	Real-time I/O, PWM Control, LED LED array Driver
LED LED array	13 x 8 (104 LEDs)	Physical HUD / Mouth Visual Feedback
VIEW FULL ARDUINO UNO Q SPECIFICATIONS

The Arduino Uno Q features a high-performance Qualcomm QRB2210 microprocessor (MPU) running Linux, which includes the Adreno 702 GPU for dedicated graphics and AI tasks. This MPU is interconnected with an STM32U585 microcontroller (MCU) dedicated to real-time execution.

Because this is a new board, there was no prior code to reference. I let AI give it a shot, and the results were way off. It tried to generate custom communication scripts, but the serial links were fragile; they would lose the port entirely upon reboot. The solution was found by analyzing the official Arduino_RouterBridge implementation to create a robust RPC (Remote Procedure Call) architecture. You can find more details in the official Arduino App Lab examples.

The Technical Wall: Port Persistence

When I started, the goal was to leverage my previous work, such as my tutorials on local LLM integration.

I also integrated my custom Gemini API AI chat interfaceto get this Arduino Uno Q project running.

My initial attempts with AI-generated communication scripts failed because the serial links were too fragile. The solution was to move away from raw serial streams and implement a robust RPC architecture using the Arduino_RouterBridge. This ensures that even after a reboot, the "Brain" (MPU) never loses the "Body" (MCU).

1. The Body (MCU): Real-Time Reflexes

The STM32 side handles physical execution. In the Desk Bot, this is the LED LED array "mouth." Note that the Arduino Uno Q LED array is a 13 x 8 grid, distinct from the 12 x 8 grid on the R4 WiFi.

mcu_handshake.ino

// Initialize the Bridge and provide 'set_mouth' function Bridge.begin(); Bridge.provide("set_mouth", set_mouth); int set_mouth(int state) { talkState = state; // Updates physical state return state; // Confirm back to Brain }

2. The Brain (MPU): High-Level Command

The Qualcomm MPU handles the system control and high-level Python commands. Instead of managing raw serial bits, the VTM OS uses the bridge to trigger functions defined in the C++ code on the MCU side.

vtm_brain.py

# --- VTM PROPRIETARY BOOT SEQUENCE --- print(" ████▒▒▒▒▒▒ 40% [MOUNTING sensor link PROTOCOL]") # Triggering the mouth to talk via the established RPC Link bridge.call("set_mouth", 1) _ EXECUTION SUCCESSFUL |

VTM OS Chat Mode & LED array Synchronization

The core focus of this article is the seamless synchronization between the VTM OS chat control and the physical hardware. In the video below, you can see the 13x8 LED LED array animated in real-time, responding to the AI voice output.

The Direct Hook

By establishing a rock-solid data link between the Linux OS and the MCU, we have created The Direct Hook. If the Linux Brain can successfully command the "face," it can command anything—validating the entire architecture for the next phase of this Arduino Uno Q project: 6-DOF Servo Integration.

The Full MCU Sketch

Below is the complete C++ sketch that lives on the STM32 side of the board. This code manages the RPC handshake and the flicker animation control for the 13x8 LED array.

vtm_mouth_controller.ino

/* ============================================================================= PROJECT: VideotronicMaker OS (VTM-OS) - The Body FILE: vtm_mouth_controller.ino AUTHOR: Tishin Padilla (VideotronicMaker) DATE: 2025-12-09 VERSION: 1.0.0 DESCRIPTION: This sketch runs on the dedicated STM32 Microcontroller (MCU) of the Arduino Uno Q. Its primary role is to execute control commands for the LED LED array mouth animation. It functions as the 'Body' in the Dual-Brain architecture, taking commands from the Linux MPU via the Arduino Router Bridge (RPC). ASSISTANT: Code control and structure assisted by Google Gemini. LICENSE: FREE and Unrestricted for all use (Public Domain). ============================================================================= */ // ======================= // 1. LIBRARY INCLUDES // ======================= #include <ArduinoGraphics.h> // Necessary for drawing shapes on the display. #include <Arduino_LED_Matrix.h> // Required for accessing the built-in 13x8 LED LED array hardware. #include <Arduino_RouterBridge.h> // **CRITICAL:** Enables Remote Procedure Calls (RPC) // between the Linux MPU (Python) and the STM32 MCU (C++). ArduinoLEDMatrix LED array; // ======================= // 2. CONSTANTS & STATE // ======================= // Define the ON and OFF colors for the LED LED array (White and Black). const uint32_t ON_COLOR = 0xFFFFFFFF; const uint32_t OFF_COLOR = 0x00000000; // Global State Variable: Controls the animation loop in loop(). // 'volatile' ensures the variable is read correctly when updated by the Bridge interrupt. volatile int talkState = 0; // 0 = Mouth Closed (Idle), 1 = Talking (Animating) // ======================= // 3. DRAWING FUNCTIONS // ======================= // FUNCTION: drawMouthClosed // Purpose: Draws the idle, horizontal line on the LED LED array. void drawMouthClosed() { LED array.beginDraw(); LED array.clear(); LED array.stroke(ON_COLOR); LED array.fill(ON_COLOR); // SHAPE 1: Waiting/Closed (A simple horizontal rectangle) LED array.rect(1, 3, 10, 2); LED array.endDraw(); } // FUNCTION: drawRandomMouth // Purpose: Selects a random mouth shape (from 3 options) and renders it. // This gives the impression of speaking without high-level TTS analysis. void drawRandomMouth() { LED array.beginDraw(); LED array.clear(); LED array.stroke(ON_COLOR); LED array.fill(ON_COLOR); // Randomly select one of the 3 open shapes (0, 1, or 2) int shapeIndex = random(0, 3); if (shapeIndex == 0) { // SHAPE 2: Fully Open (Smiley/Wide Vowel Sound) LED array.rect(0, 0, 12, 2); LED array.rect(0, 2, 2, 1); LED array.rect(11, 2, 1, 1); LED array.rect(1, 3, 2, 1); LED array.rect(10, 3, 2, 1); LED array.rect(1, 4, 2, 1); LED array.rect(9, 4, 2, 1); LED array.rect(2, 5, 2, 1); LED array.rect(8, 5, 2, 1); LED array.rect(3, 6, 2, 1); LED array.rect(7, 6, 2, 1); LED array.rect(3, 7, 6, 1); } else if (shapeIndex == 1) { // SHAPE 3: Half Open (Resting Position) LED array.rect(1, 1, 10, 2); LED array.rect(1, 3, 2, 2); LED array.rect(10, 3, 1, 2); LED array.rect(9, 4, 1, 1); LED array.rect(2, 5, 8, 1); } else { // SHAPE 4: Narrow Open (O-shape/Tense Vowel) LED array.rect(2, 1, 8, 1); LED array.rect(3, 2, 6, 1); LED array.rect(3, 3, 1, 3); LED array.rect(8, 3, 1, 3); LED array.rect(4, 6, 4, 1); } LED array.endDraw(); } // ======================= // 4. BRIDGE FUNCTIONS (RPC) // ======================= // RPC FUNCTION: set_mouth // **CRITICAL BRIDGE LINK:** This function is called directly by the Python/Flask // server running on the Linux MPU. It receives the 'state' integer via the // internal serial bridge. int set_mouth(int state) { // Update the global state based on the MPU's command. talkState = state; // Return the state for confirmation to the MPU (standard RPC practice). return state; } // ======================= // 5. ARDUINO SETUP // ======================= void setup() { // Initialize the LED LED array hardware. LED array.begin(); // Initialize the Router Bridge (The communication link to the Linux MPU). Bridge.begin(); // Provide the function 'set_mouth' to the Linux MPU. Bridge.provide("set_mouth", set_mouth); drawMouthClosed(); } // ======================= // 6. MAIN LOOP // ======================= void loop() { if (talkState == 1) { drawRandomMouth(); Bridge.update(); delay(80); } else { static int lastState = -1; if (lastState != 0) { drawMouthClosed(); lastState = 0; } Bridge.update(); } }

GITHUB REPOSITORY
Access the VTM OS Source PROJECT HUB
Detailed Build Guide LINKEDIN POST
Join the Discussion

BENCH FAQ // PYTHON RPC & HARDWARE CONTROL

Frequently Asked Questions

Arduino_RouterBridge RPC protocol, LED matrix animation drivers, 1.8V vs 3.3V logic level isolation, non-blocking polling loops, and VTM Studio Workbench integration.

1. How does Python on the Qualcomm Linux MPU communicate with the STM32 MCU on the Arduino Uno Q? +

The Arduino Uno Q runs an internal Arduino_RouterBridge daemon that routes Remote Procedure Calls (RPC) over a high-speed internal serial bus. When a Python script on the Qualcomm Linux MPU invokes a command (such as board.digital_write(pin, HIGH) or board.analog_read(pin)), the call is serialized into a lightweight binary packet, transmitted to the STM32 real-time coprocessor, and executed at deterministic hardware speeds.

2. How do you drive custom animations or text onto the Uno Q LED matrix using Python? +

The onboard LED matrix connects to the STM32 MCU GPIO matrix. In Python, import the board RPC library, initialize the display driver, and pass 2D boolean arrays or hex framebuffers representing your pixel icons (e.g. matrix.draw_bitmap(frame)). The Python script controls animation timing and frame sequencing while the STM32 handles the high-frequency row-column multiplexing loop.

3. What electrical precautions are required when interfacing Python scripts with external sensor hardware? +

Keep in mind the strict voltage separation: pins connected to the STM32 MCU header operate at 3.3V logic, while high-speed peripheral pins connected to the Qualcomm MPU (such as the JMISC header) operate at 1.8V. Never wire 3.3V or 5V sensors directly to a 1.8V MPU header without an active bidirectional level shifter.

4. How do you prevent high-frequency Python sensor polling from saturating the internal RPC link? +

Polling RPC calls inside an unconstrained while True loop can flood the internal UART buffer and spike CPU usage. Always introduce non-blocking event delays using time.sleep(0.01) (10ms) or subscribe to asynchronous event callbacks provided by the bridge library so the STM32 only pushes data packets when sensor thresholds change.

5. How does this Python hardware control tutorial integrate with VTM Studio? +

VTM Studio provides full Python script execution and terminal debugging directly inside Code Mode. Telemetry data returned from your Python RPC calls streams in real time to Science Mode dials and Maker Log Mode notebooks without leaving the native workbench.