The Heart of Motion: How BLDC Motors Work and Why Systems Lag

In high-performance robotics, such as autonomous blimps or racing drones, the speed at which a motor can reach its target thrust determines the stability of the entire system. While Brushless DC (BLDC) motors are highly efficient, they are not instantaneous. Understanding the raise time delay is critical for accurate modeling and control.

1. How a BLDC Motor Works

A BLDC motor is an electronically commutated motor. Unlike brushed motors that use physical contact to flip magnetic fields, BLDC motors use an Electronic Speed Controller (ESC) to energize stator coils in a specific sequence.

Electronic Commutation: The ESC must know the rotor’s position to fire the correct coil at the right time.
Magnetic Interaction: The permanent magnet rotor “chases” the rotating magnetic field created by the stator.
Efficiency: Because there are no brushes, there is no friction-related energy loss or mechanical wear, allowing for higher RPMs.

2. What Causes Delay in BLDC Systems?

When you send a command to a motor, several physical and electrical factors prevent it from reaching the desired thrust immediately:

Inductive Lag: Current cannot change instantly in the motor’s copper windings due to inductance.
Mechanical Inertia: The rotor and attached propeller have mass that must be accelerated, which requires time to translate torque into thrust.
Transition Variations: The delay isn’t uniform. Research shows that switching from Forward to Reverse ( $1114.4$ ms) takes significantly longer than switching from Neutral to Full Forward ( $221.2$ ms).

3. The Mathematical Model: First-Order Systems

To simulate how a motor behaves, we can use a First-Order Differential Equation. This allows us to predict the thrust $f(t)$ at any given time:

$f(t) = F_{SS} \left[ 1 - e^{\frac{-t}{\tau}} \right]$

Key Variables:

$F_{SS}$ (Steady-State Thrust): The final target thrust.
$\tau$ (Time Constant): The “speed” of the motor’s response.

Calculating $\tau$ from Experimental Data

By measuring the Rise Time ( $t_r$ ), which is the time to go from $10\%$ to $90\%$ of the target thrust, we can find $\tau$ using the relationship $t_r \approx 2.2\tau$ .

For example, if experimental data shows a rise time of 0.5 seconds: $\tau = \frac{0.5}{2.2} \approx 0.227 \text{ seconds}$

4. Simulating the Behavior in Python

With the equation $F(t) = F_{ss} [ 1 - e^{-t/0.227} ]$ , we can write a simulation to compare theoretical performance against real-world captured data.

import math
import numpy as np

def motor_simulation(time_steps, target_thrust):
    """
    Receives required thrust and time, returns current thrust
    based on a first-order model with tau = 0.2.
    """
    thrust_history = []
    tau = 0.2  # Time constant derived from research

    for t in time_steps:
        if t > 0.1: # Account for initial command latency
            thrust = target_thrust * (1 - math.exp(-t / tau))
            thrust_history.append(thrust)
        else:
            thrust_history.append(0.0)

    return thrust_history

Summary Table: Transition Time Research

Based on empirical testing, the time constant ( $\tau$ ) varies based on the magnitude of the PWM change ( $\Delta$ PWM):

Transition Direction	$\Delta$ PWM	Avg $\tau$ (ms)	Rise Time $t_r$ (ms)
Full Fwd to Full Rev	1000	1114.4	2451.7
Neutral to Full Fwd	500	221.2	486.6
Full Fwd to Neutral	500	161.8	356.0

Conclusion

Modeling the rise time delay is the difference between a robot that wobbles and one that moves with precision. By treating the motor as a first-order system and identifying your specific $\tau$ , you can build compensators in your control code to “expect” the lag rather than being fought by it.