Arduino® UNO Q - Inverted Pendulum | PID + UI

Rotary Encoder ABZ 1000Z

90º Pendulum Rod

A4988 Stepper Motor Driver

Nema 17 Stepper Motor

Generic Soldering Iron

3D Printer (Ender 3 V3)

12 Volts 2 Amps Power Supply

Screwdriver Set

M3 Screws

Prototyping PCB

Arduino App Lab

Arduino UNO Q

<html><body>This project showcases a real-time PID control system designed to balance an inverted pendulum using the Arduino UNO Q. It provides a fully interactive, web-based dashboard that allows users to dynamically tune the Proportional-Integral-Derivative (PID) control gains. By connecting a stepper motor to drive the pendulum and an A/B quadrature encoder to measure its angle, the system achieves closed-loop control. <figure><iframe src="https://youtu.be/C8g5xPdpfjU"></iframe></figure><h3>📐 Theoretical Context</h3>PID Control for an Inverted Pendulum The goal of this system is to maintain the pendulum at an unstable setpoint of 180 degrees (perfectly upright). This is a classic control problem that is solved using a PID controller. <figure><img src="https://projects.arduinocontent.cc/61ba9773-770d-48ab-a3be-ba423c8d3598.png"/><figcaption>PID control loop diagram</figcaption></figure> A PID controller calculates an "error" value as the difference between a desired setpoint and a measured process variable (the pendulum's current angle). It then computes a control drive signal using three separate terms: <ol><li>Proportional (P-term): This term is proportional to the current error. A larger error results in a stronger, immediate corrective move. This provides the bulk of the initial driving force. </li><li>Integral (I-term): This term is proportional to the accumulation of past errors over time. It eliminates steady-state error (the difference between the setpoint and the actual angle when the system has settled). It's crucial for overcoming constant disturbances like friction or gravity bias. </li><li>Derivative (D-term): This term is proportional to the rate of change of the error. It acts as a dampener, counteracting fast movements and reducing overshoot, which is vital for stabilizing the inverted pendulum. </li></ol>In this application, the UNO Q reads the encoder angle, calculates the shortest-path angular error (which correctly handles the 360º wrapping), and outputs a <code class="code">move_deg </code>signal. This signal is clamped between -20º and +20º per cycle and is then converted into a new target step position for the stepper motor. The stepper motor, driven by an A4988 driver, uses the control signal to move its shaft, attempting to keep the pendulum upright. The motor's movement is managed by the <code class="code">SimpleStepper </code>class, which implements a trapezoidal acceleration/deceleration profile for smooth motion. <h3>🛠️ Build the Inverted Pendulum</h3>Mechanical Parts <figure><img src="https://projects.arduinocontent.cc/060b41e9-7108-4674-b826-e17ffa2be86f.png"/><figcaption>Mechanical parts</figcaption></figure> The mechanical assembly involves mounting the main components to create the pendulum structure: <ol><li>Base and Tower: The 3D-printed pendulum tower is securely screwed onto the base plate. </li><li>Stepper Motor: The NEMA 17 Stepper Motor is fastened to the top of the tower. </li><li>Encoder Assembly: The Rotary Encoder (1000 steps/rotation) is attached to the custom motor/shaft adapter. </li><li>Pendulum Rod: The 90º pendulum rod is screwed onto the encoder shaft. </li></ol>Electronics <figure><img src="https://projects.arduinocontent.cc/ad7ef56c-af32-41dc-9fe5-4265924786b1.png"/><figcaption>Project wiring diagram</figcaption></figure> The electronic components are wired via a custom prototype PCB: <ol><li>A4988 Driver: This module is mounted on the PCB to control the Stepper Motor, receiving STEP and DIR signals from the MCU (D3 and D2, respectively) </li><li>Microstepping: Software control on pins MS1, MS2, MS3 (D6, D5, D4) are used to set the microstepping. The firmware is set to 16x microstepping ( <code class="code">set_step_mode(4) </code>) for smoother control, trading off torque for resolution. </li><li>Encoder Connection: The encoder's A and B channels are connected to pins A0 and A1 of the UNO Q, using interrupt-driven logic for high-accuracy position reading. </li><li>UNO Shield: The PCB's bottom connectors allow it to be plugged directly onto the Arduino UNO Q's main headers, acting as a dedicated shield. </li></ol><h3>🖥️ Dashboard</h3>The web dashboard is the main interface for interacting with the control system. <figure><img src="https://projects.arduinocontent.cc/e66c1e64-8ef7-4023-8460-ed735b957c2c.png"/><figcaption>App user interface</figcaption></figure> Dashboard Elements <ol><li>PID Fields: Input fields for Kp, Ki, Kd, and Bias allow for dynamic tuning. The <code class="code">Apply PID </code>button sends these values to the microcontroller via the backend's REST API, instantly updating the control logic. </li></ol>Control Buttons: <ol><li>Start Control: Initiates the PID control loop on the microcontroller. </li><li>Stop Control: Halts the control loop. </li><li>Zero Encoder: Calibrates the encoder and stepper positions to 0. </li><li>Clear Results: Clears the telemetry buffers on the MPU. </li><li>Status Badge: Displays the current state ( <code class="code">idle </code>, <code class="code">running </code>, <code class="code">finished </code>, <code class="code">zeroing </code>). </li></ol>Real-Time Charts: Four charts provide live visualization of the system's performance: <ol><li>Microcontroller intervals (ms): Shows the control loop execution time. </li><li>Encoder angle (deg): Tracks the pendulum's angle with a reference line for the 180º setpoint. </li><li>Stepper angle (deg): Shows the absolute position of the stepper motor shaft. </li><li>Drive signal (move_deg): Visualizes the control output sent by the PID algorithm to the stepper motor. </li></ol><h3>💾 Software Architecture Overview</h3>The application is built using Arduino App Lab, which neatly separates the project into microcontroller (MCU) and microprocessor (MPU) responsibilities. MCU ( sketch.ino , stepper.h ) Handles the high-speed, deterministic tasks: <ol><li>Reads the encoder position </li><li>Performs the PID calculation at every control cycle </li><li>Drives the stepper motor using the <code class="code">SimpleStepper </code>class (which implements trapezoidal acceleration) </li><li>Implements safety guards (circular and absolute travel limits) </li><li>Uses the Bridge to send real-time telemetry data ( <code class="code">record_control_tick </code>) and notify the MPU when the episode ends ( <code class="code">end_control_episode </code>) </li></ol>MPU ( main.py ) Handles the application logic and communication bridges: <ol><li>Manages telemetry data buffers ( <code class="code">intervals </code>, <code class="code">enc_degs </code>, etc.) up to 50,000 samples </li><li>Exposes REST API endpoints (e.g., <code class="code">/metrics </code>, <code class="code">/set-pid </code>) for the frontend to communicate with. </li><li>Acts as a Bridge RPC caller to control the MCU (e.g., <code class="code">ctl/start </code>, <code class="code">ctl/set_pid </code>) </li><li>Acts as a Bridge RPC provider to receive real-time data from the MCU ( <code class="code">record_control_tick </code>) </li><li>Uses WebUI (Socket.IO) to push events (like <code class="code">episode_finished </code>) to the frontend for automatic chart updates </li></ol>Frontend (WebUI Brick) The frontend is served by the web_ui Brick and consists of: <ol><li><code class="code">index.html </code>: The structure of the web page. </li><li><code class="code">style.css </code>: Defines the layout and appearance. </li><li><code class="code">app.js </code>: Handles user interaction (button clicks), communicates with the MPU via REST API, and renders the real-time charts using HTML5 Canvas. It also uses Socket.IO to listen for MPU events, ensuring charts are automatically updated when an episode finishes. </li></ol>Setting up the Project in Arduino App Lab You can download the whole App from the GitHub repository linked at the bottom of this tutorial. Through an SSH or ADB connection to your UNO Q from a terminal lets clone the repository in the user Apps directory: <pre>cd ArduinoApps </pre><pre>git clone https://github.com/mcmchris/uno-q-inverted-pendulum-pid.git </pre>This is the simpler way to get the complete App added to your UNO Q, now from the Arduino App Lab you can find it in " My Apps ". <figure><img src="https://projects.arduinocontent.cc/78469f6e-bb99-42b2-96f6-dfc4394778b2.png"/><figcaption></figcaption></figure> <h3>🧑‍💻 Deep Dive into the Code</h3>The primary control logic resides in the <code class="code">loop() </code>function of <code class="code">sketch.ino </code><ol><li>Timing: The interval time Δt (in seconds) is calculated using <code class="code">micros() </code>to ensure a stable sample rate, regardless of the loop speed. </li></ol><pre>	 unsigned long now_us = micros(); </pre><pre>	 float interval_s = (now_us - last_us) / 1000000.0f; </pre><pre>	 if (interval_s &lt;= 0.0f) return; </pre><pre>	 last_us = now_us; </pre><ol><li>Sensing: <code class="code">get_encoder_angle() </code>returns the wrapped pendulum angle (0 to 360º). </li></ol><pre>float enc_deg = get_encoder_angle(); </pre><ol><li>Error Calculation: <code class="code">shortestAngleError(SETPOINT_DEG, enc_deg) </code>calculates the shortest path from the current position to the 180º setpoint, resulting in an error in the range (-180º, 180º]. </li></ol><pre>	 float error = shortestAngleError(SETPOINT_DEG, enc_deg); </pre><ol><li>Safety Guard: A circular guard checks if the absolute error exceeds the <code class="code">GUARD_HALF_WIDTH </code>(20º) and stops the motor if the pendulum swings too far away from the 180º setpoint. </li></ol><pre>	 if (fabsf(error) &gt; GUARD_HALF_WIDTH){ </pre><pre>	 Monitor.print(F("Guard hit (circular): |err|=")); </pre><pre>	 Monitor.println(fabsf(error), 2); </pre><pre>	 stop_control(F("Out of range")); </pre><pre>	 return; </pre><pre>	 } </pre><ol><li>PID Calculation: The control signal <code class="code">move_deg </code>is computed: </li></ol>move_deg = K_P*error + K_I*integral + K_D*derivative + BIAS <pre>// PID </pre><pre>	 integral += (error * interval_s); </pre><pre>	 if (integral &gt; INTEGRAL_CLAMP) integral = INTEGRAL_CLAMP; </pre><pre>	 if (integral &lt; -INTEGRAL_CLAMP) integral = -INTEGRAL_CLAMP; </pre><pre>	 float derivative = (error - prev_error) / interval_s; </pre><pre>	 float move_deg = (K_P * error) + (K_I * integral) + (K_D * derivative) + BIAS; </pre><pre>	 if (move_deg &gt; MOVE_DEG_CLAMP) move_deg = MOVE_DEG_CLAMP; </pre><pre>	 if (move_deg &lt; -MOVE_DEG_CLAMP) move_deg = -MOVE_DEG_CLAMP; </pre><ol><li>Motor Actuation: The resulting <code class="code">move_deg </code>is clamped to ±20º. A final absolute travel guard stops the motor if its total rotation exceeds 360º (to protect wiring). Otherwise, the <code class="code">move_deg </code>is converted to <code class="code">deltaSteps </code>and sent to the stepper motor via <code class="code">stepper.move() </code>. </li></ol><pre>	 // Guard on motor rotation from startpoint </pre><pre>	 if ((MAX_STEPPER_ABS_DEG != 0) &amp;&amp; (abs(stp_deg + move_deg) &gt; MAX_STEPPER_ABS_DEG)) { </pre><pre>	 stop_control(F("Wires Protected (360)")); </pre><pre>	 return; </pre><pre>	 }else{ </pre><pre>	 long deltaSteps = degToSteps(move_deg); </pre><pre>	 stepper.move(deltaSteps); </pre><pre>	 } </pre><ol><li>Telemetry: The 4-value telemetry packet (interval, encoder angle, stepper angle, control output) is sent to the MPU via Bridge. </li></ol><pre>	 float interval_ms = interval_s * 1000.0f; </pre><pre>	 Bridge.notify("record_control_tick", interval_ms, enc_deg, stp_deg, move_deg); </pre><h3>🎚️ Tuning PID Controller</h3>PID tuning is typically an iterative process of trial and error, aiming to find the right balance between responsiveness, stability, and steady-state error. Since the inverted pendulum is an inherently unstable system, the order of tuning and the relative strength of the terms are particularly critical. You will use the web interface to adjust the Kp , Ki , and Kd values and observe the results on the real-time charts. Step-by-Step Tuning Procedure The goal is to increase the gains until the system responds correctly without oscillating wildly or failing the safety guard (20º circular limit). <ol><li>Proportional Gain (Kp) - The Primary Driver </li></ol>Action: Slowly increase Kp from zero (e.g., in increments of 0.01). Apply PID and then Start Control after each adjustment. Observation: The Proportional term provides the restoring force. Too little Kp will result in the pendulum immediately falling. Increase Kp until the pendulum begins to react strongly to the error and shows a rapid tendency to move towards the setpoint, but it might still overshoot or oscillate. Effect: It reduces the rise time but increases overshoot and oscillations. <ol><li>Derivative Gain (Kd) - The Dampener </li></ol>Action: Keep the established Kp and introduce Kd (e.g., in increments of 0.01). Observation: The Derivative term counteracts the rate of change of the error, effectively acting as a dampening force. Increase Kd until the rapid oscillations caused by Kp are reduced or eliminated, leading to a stable, upright position. This is the most critical term for stability in an inverted pendulum. Effect: It improves stability, reduces overshoot, and decreases settling time. <ol><li>Integral Gain (Ki) - The Error Corrector </li></ol>Action: Once the pendulum is relatively stable, introduce a very small Ki (e.g., in increments of 0.001). Observation: The Integral term accumulates small, constant errors (like the offset due to slight friction or motor bias) and slowly adjusts the control signal to eliminate them. Too high of a Ki will cause integral windup (though the firmware limits this) and slow, persistent oscillation. You only need enough Ki to hold the position accurately over time. Effect: It eliminates steady-state error. <ol><li>Bias </li></ol>Action: Adjust the Bias if the pendulum consistently drifts to one side or requires constant small movements even when perfectly upright. Observation: The Bias provides a fixed offset to the control signal, which can be useful to manually compensate for an unequal gravitational pull or mechanical imbalance. </body></html>

Complete Arduino App Lab Application

3D Encoder Adapter

3D Pendulum Base

3D Pendulum Tower

Arduino® UNO Q - Inverted Pendulum | PID + UI

Arduino UNO Q Inverted Pendulum Controller with dynamic tuning and real-time user interface