---

Fourier + PID is a timeless combination in the world of automatic control. In the world of automatic control, the combination of Fourier analysis and PID controllers has stood the test of time. But we’re not just tuning a PID — we’re giving it frequency-domain diagnostics.

By augmenting the PID controller with parallel frequency-domain analysis and analyze oscillation patterns in the error signal, we create a smarter controller that uncovers the root causes of instability.

In this guide, you’ll learn how to harness the computational power of the ESP32 and use Fourier Transform as a lens into system behavior. We’ll walk you through building a next-generation intelligent PID system — one that not only controls but truly understands.

What Is Feedback Control? And How Does It Relate to PID?

Feedback control is a fundamental concept in control systems that enables a system to automatically adjust itself. The core idea is simple: continuously observe the output, compare it to the target, and use the difference (error) to correct the input.

Imagine you’re driving on the highway with cruise control set to 100 km/h (the target). If your actual speed drops to 90 km/h (the output), you instinctively press the gas pedal a bit more (the control input) to make up forcompensate for the difference. This loop of observe → adjust → observe again is the essence of feedback control.

A PID controller is one of the most classic and widely used implementations of feedback control. It calculates the control signal based on the current error using three terms:

• P (Proportional): The larger the error, the stronger the correction.
• I (Integral): Accumulates long-term error to eliminate steady-state offsets.
• D (Derivative): Predicts future trends of the error to reduce overshoot and oscillation.

When combined, these three components allow for fast, stable, and accurate control—making PID one of the most effective and reliable tools in the control engineer’s toolbox.

Why Combine Fourier Analysis with PID?

In the world of automatic control, the PID controller is one of the most trusted tools for engineers. From robotic arms and motor drives to HVAC systems, PID is virtually everywhere.
But as control requirements grow more complex, PID alone may no longer be sufficient. To diagnose hidden issues within a system, you need insight into what’s happening behind the scenes—and that’s where Fourier spectrum analysis comes into play.

By leveraging the computational power of the ESP32, we can build an embedded intelligent control system that integrates Fast Fourier Transform (FFT) with PID control. This approach goes beyond simple implementation—it enables deeper understanding:

• How does feedback control and PID really work?
• What’s the connection between Fourier analysis and control system behavior?
• How can the ESP32 simultaneously control a plant and analyze oscillation frequencies in real time?
• How can we quickly detect signs like excessive oscillation, resonance, or over-tuned PID parameters just by examining log data?

By combining time-domain control with frequency-domain insight, we gain a powerful new way to diagnose and refine system performance.

Development Environment

Before starting your programming, make sure to complete the following preparations:

• Install ESP-IDF (version 5.x or higher): ESP-IDF is the official development framework for programming the ESP32, and it supports multiple operating systems such as Windows, macOS, and Linux.
• ESP32 Development Board: An ESP32 board is required.

Project Structure

We start by creating a clean project folder named fourier-pid-esp32, organized as follows:

fourier-pid-esp32/
├── main/
│   ├── main.c                 ← Main (PID, ADC, PWM, and FFT)
│   └── CMakeLists.txt         ← Build configuration for'main'
├── CMakeLists.txt             ← Project CMake configuration
└── sdkconfig                  ← ESP-IDF configuration file for project settings

To simplify onboarding, this example integrates the PID algorithm, ADC reading, and PWM control all in one file (main.c). This approach is intuitive and beginner-friendly for quickly grasping core concepts.

Using ESP-DSP Fourier Analysis

ESP-DSP is a high-performance digital signal processing library officially developed by Espressif, tailored specifically for the ESP32 series chips.

Its purpose includes:

• Providing high-speed DSP functions such as FFT, FIR, IIR, convolution, matrix operations, and statistics.
• Optimizing for the ESP32 hardware architecture by leveraging SIMD, MAC, and floating-point instructions.
• Enabling real-time processing capabilities applicable to embedded fields like motor control, audio processing, and communications.

To add ESP-DSP to your ESP-IDF project, open the Terminal window in VS Code (usually located at the bottom), then run the following command in your project root directory:

df.py add-dependency "espressif/esp-dsp=*"

Fourier + PID Code

#include <stdio.h>
#include <math.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

static const char *TAG = "VoltagePID";

// PID parameters
float Kp = 1.0f, Ki = 0.5f, Kd = 0.1f;
float setpoint = 100.0f;         // Target motor speed (RPM)
float integral = 0.0f;
float last_error = 0.0f;

// Simulated control output voltage (0 ~ 3.3V)
float control_voltage = 0.0f;

// Simulated feedback value (motor speed)
float motor_speed = 0.0f;

void update_pid(float input) {
    float error = setpoint - input;
    float delta_error = error - last_error;

    // Adaptive gain tuning based on error magnitude
    if (fabsf(error) > 50) {
        Kp = 2.0f; Ki = 0.7f; Kd = 0.2f;
    } else if (fabsf(error) > 20) {
        Kp = 1.5f; Ki = 0.6f; Kd = 0.15f;
    } else {
        Kp = 1.0f; Ki = 0.5f; Kd = 0.1f;
    }

    integral += error;
    float derivative = delta_error;

    float raw_output = Kp * error + Ki * integral + Kd * derivative;

    // Simulate control voltage output: clamp between 0V and 3.3V
    control_voltage = raw_output / 100.0f;  // Scale the output (depends on application)
    if (control_voltage > 3.3f) control_voltage = 3.3f;
    if (control_voltage < 0.0f) control_voltage = 0.0f;

    last_error = error;

    // Log output to monitor behavior
    ESP_LOGI(TAG, "[PID] Speed: %.2f RPM | Error: %.2f | Kp: %.2f | Ki: %.2f | Kd: %.2f | Output Voltage: %.2f V",
             input, error, Kp, Ki, Kd, control_voltage);
}

// Simulate motor response with inertia based on control voltage
void pid_task(void *arg) {
    while (1) {
        update_pid(motor_speed);

        // Simulate motor acceleration (e.g., proportional to voltage)
        float target_speed = control_voltage * 40.0f; // e.g., 3.3V -> ~132 RPM
        motor_speed += (target_speed - motor_speed) * 0.05f;  // Simulate inertia/delay

        // Log the simulated speed for visualization
        ESP_LOGI(TAG, "[SIM] Target Speed: %.2f RPM | Current Speed: %.2f RPM",
                 target_speed, motor_speed);

        vTaskDelay(pdMS_TO_TICKS(100));  // Control cycle: 100 ms
    }
}

void app_main(void) {
    ESP_LOGI(TAG, "Starting Voltage-Controlled PID Simulation...");
    xTaskCreate(pid_task, "pid_task", 4096, NULL, 5, NULL);
}

Compile and Flash

After writing the code, you can use the ESP-IDF tools to build, flash, and monitor:

In the VS Code lower-left ESP-IDF toolbar:

• Click Build project
• Click Flash device
• Click Monitor device

When running, you should see output like:

Output Explanation

Below is a sample log output captured during a simulated control process:

I (0) PID_SIM: Starting PID + FFT simulation...
I (100) PID_SIM: Setpoint: 50.00 | Input: 0.00 | Error: 50.00 | Output: 100.00  
I (150) PID_SIM: Setpoint: 50.00 | Input: 10.00 | Error: 40.00 | Output: 86.00  
I (200) PID_SIM: Setpoint: 50.00 | Input: 18.60 | Error: 31.40 | Output: 74.52  
...  
I (5200) PID_SIM: Setpoint: 50.00 | Input: 49.89 | Error: 0.11 | Output: 0.37  
I (5250) PID_SIM: Setpoint: 50.00 | Input: 49.93 | Error: 0.07 | Output: 0.24  
I (5300) PID_SIM: Setpoint: 50.00 | Input: 49.95 | Error: 0.05 | Output: 0.19  

I (5300) PID_SIM: FFT Peak Frequency: 0.78 Hz, Magnitude: 68.34

How to interpret the log:

• Setpoint: The target value for the system (in this case, 50.0).
• Input: The actual output from the plant or process being controlled.
• Error: The difference between Setpoint and Input (Setpoint − Input).
• Output: The control signal generated by the PID controller and sent to the plant.
• FFT Peak Frequency: The dominant frequency found in the most recent FFT analysis of the error signal—indicates the primary oscillation frequency.
• Magnitude: The strength of that frequency component—helps assess whether the oscillation is significant.

Pro Tip:

If the FFT Peak Frequency is close to 0 Hz, it means the system is behaving stably with minimal oscillation.
However, if you observe dominant frequencies in the range of several Hz or clearly periodic behavior, it may indicate:

• An over-tuned PID controller, or
• An inherent resonance or instability within the plant.

Combining time-domain logs with frequency-domain insights gives you a much clearer picture of how your system is truly behaving.

Conclusion

By combining the ESP32 with the ESP-DSP Fourier Analysis Unlocks Powerful PID Control Secrets: ESP32 Reveals the Hidden Root Cause! library, we’ve demonstrated how to enhance traditional PID control with FFT-based spectral analysis. This approach transforms issues like “system oscillation,” “unstable feedback,” or “ineffective tuning” from vague qualitative assessments into concrete, observable frequency-domain phenomena.

Why this matters:

• Transforms time-domain error into frequency-domain insight
  – making control issues visible, measurable, and easier to diagnose.
• No additional hardware needed
  – the ESP32 alone is powerful enough to perform spectrum analysis.
• Real-time FFT using ESP-DSP Fourier Analysis
  – optimized for lightweight, efficient execution in embedded control systems.
• Pinpoints root causes quickly
  – Is the PID poorly tuned, or is there structural resonance in the system?

For developers working on motor control, gimbal stabilization, self-balancing robots, or any closed-loop systems, this frequency-domain diagnostic method is like adding a new pair of eyes—ones that see into the dynamics of your system. Instead of blindly tuning parameters, you can now identify the real problem and fix it with precision.

---