Development of Digital PID Controllers in 32-Bit Microcontrollers for High-Precision Electromechanical Actuators

Fundamentals of PID Control Applied to Physical Systems

PID controllers (Proportional, Integral, and Derivative) act as the brain of any system that needs to move something to an exact location and hold it there without endless hesitation. Think of a PID controller like an experienced driver looking at the distance to a traffic light: if it is far away, they step heavily on the gas; as they get closer, they ease off; if they overshoot slightly, they reverse slightly. In practice, this means the proportional part handles the current error, the integral part corrects accumulated past errors (like a headwind pushing the car), and the derivative part anticipates the speed of change to prevent abrupt braking.

When migrating this mathematical logic to high-precision electromechanical actuators, such as closed-loop stepper motors or DC servos, the challenge changes shape. We are no longer dealing purely with theoretical equations on paper, but with the real world, full of friction, mechanical backlash, inertia, and electrical noise. If the controller is slow or inaccurate, the motor will vibrate, overheat excessively, or take too long to reach the desired position, compromising the entire equipment.

Why 32-Bit Microcontrollers Change the Game

In the past, engineers struggled to implement these equations on 8-bit chips, where every multiplication required complex fixed-point tricks to avoid overflowing processing capacity. Today, modern 32-bit microcontrollers bring dedicated floating-point units, capable of calculating complex decimal numbers in a single clock cycle. In practice, this means we can run extremely fast control loops, easily surpassing tens of kilohertz in sampling frequency.

This extra speed is not just for technical bragging rights. In high-precision actuators, the faster the microcontroller reads the position sensor (such as an optical encoder) and recalculates the control signal for the motor, the smoother and stiffer the mechanical movement becomes. It is the difference between a robotic arm that jitters when stopping and one that glides with absolute perfection to the millimeter target.

Software Architecture and Deterministic Sampling

Implementing an efficient digital PID requires a rigid software architecture based on timer interrupts. The worst mistake a programmer can make is putting the PID calculation inside the main application loop alongside slow communication routines. In practice, this creates variations in the time between readings, known as jitter, which destroys the stability of the mathematical system.

A robust solution consists of configuring an internal microcontroller timer to trigger an interrupt at fixed, immutable intervals, for example, exactly every one millisecond. Inside this interrupt routine, the chip reads the sensor, executes the PID equation, and updates the PWM signal (Pulse Width Modulation, which controls the power sent to the motor) before returning to the main routine.

Practical Implementation in C Language

Below we present a functional C structure for a positional PID controller with protection against integral saturation, known in the technical field as anti-windup. This protection prevents the integral term from growing indefinitely when the motor is physically stalled, preventing violent jolts when the obstacle is removed.

typedef struct {
    float kp, ki, kd;
    float error_integral;
    float previous_error;
    float output_min, output_max;
} PID_Controller;

float pid_update(PID_Controller *pid, float setpoint, float measurement, float dt) {
    float error = setpoint - measurement;
    pid->error_integral += error * dt;
    
    // Anti-windup limit on integrator
    if (pid->error_integral > pid->output_max) pid->error_integral = pid->output_max;
    else if (pid->error_integral < pid->output_min) pid->error_integral = pid->output_min;

    float derivative = (error - pid->previous_error) / dt;
    pid->previous_error = error;

    float output = (pid->kp * error) + (pid->ki * pid->error_integral) + (pid->kd * derivative);

    if (output > pid->output_max) output = pid->output_max;
    else if (output < pid->output_min) output = pid->output_min;

    return output;
}

Noise Challenges and Signal Filtering

Even with a fast processor and optimized code, the signal coming from a sensor in an industrial or laboratory environment is rarely clean. Electromagnetic noise from motors and long cables generates small spurious variations in the position reading. When the derivative term of the PID multiplies these rapid variations, the result is a chaotic output command that unnecessarily stresses the hardware.

To overcome this issue, a digital low-pass filter is applied to the sensor signal or directly to the derivative calculation. In practice, this attenuates high noise frequencies without delaying the dynamic response that the system needs to correct real disturbances. It is the delicate balance between sensitivity and noise immunity.

Final Considerations

The development of PID controllers in 32-bit microcontrollers bridges the mathematical elegance of automatic control theory with the harshness of embedded systems engineering. Mastering deterministic sampling, floating-point arithmetic, and saturation protections allows the design of electromechanical actuators capable of operating with surgical precision. With methodical bench testing and fine-tuning of gains, the system gains the robustness to face real environments without losing expected performance.