How to Reduce Drone Vibration: Tips and Code Examples

To reduce drone vibration, use software filters like low-pass filters on sensor data and tune the PID controller parameters carefully. Additionally, ensure hardware balance by checking propellers and mounting dampeners to minimize physical vibrations.

Syntax

Here is the basic syntax to apply a low-pass filter and tune PID parameters in drone control code:

• low_pass_filter(value, alpha): Smooths sensor data by blending new and old values.
• pid.update(error, dt): Updates PID controller with current error and time delta to adjust motor speeds.
• set_motor_speeds(speeds): Sends adjusted speeds to drone motors.

python

def low_pass_filter(current_value, previous_value, alpha):
    return alpha * current_value + (1 - alpha) * previous_value

class PIDController:
    def __init__(self, kp, ki, kd):
        self.kp = kp
        self.ki = ki
        self.kd = kd
        self.integral = 0
        self.previous_error = 0

    def update(self, error, dt):
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt if dt > 0 else 0
        output = self.kp * error + self.ki * self.integral + self.kd * derivative
        self.previous_error = error
        return output

# Example usage:
# filtered_value = low_pass_filter(sensor_value, last_value, 0.1)
# correction = pid.update(error, delta_time)
# set_motor_speeds(base_speed + correction)

Example

This example shows how to apply a low-pass filter to accelerometer data and use a PID controller to reduce vibration effects by adjusting motor speeds.

python

import time

# Low-pass filter function
def low_pass_filter(current_value, previous_value, alpha):
    return alpha * current_value + (1 - alpha) * previous_value

# Simple PID controller class
class PIDController:
    def __init__(self, kp, ki, kd):
        self.kp = kp
        self.ki = ki
        self.kd = kd
        self.integral = 0
        self.previous_error = 0

    def update(self, error, dt):
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt if dt > 0 else 0
        output = self.kp * error + self.ki * self.integral + self.kd * derivative
        self.previous_error = error
        return output

# Simulated sensor and motor control
class Drone:
    def __init__(self):
        self.motor_speed = 1000  # base speed
        self.filtered_accel = 0
        self.pid = PIDController(kp=1.2, ki=0.01, kd=0.05)

    def read_accelerometer(self):
        # Simulate vibration noise around 0
        import random
        return random.uniform(-5, 5)

    def set_motor_speeds(self, speed):
        self.motor_speed = speed
        print(f"Motor speed set to: {speed:.2f}")

    def stabilize(self):
        alpha = 0.1
        last_time = time.time()
        self.filtered_accel = 0
        for _ in range(10):
            current_time = time.time()
            dt = current_time - last_time
            last_time = current_time

            raw_accel = self.read_accelerometer()
            self.filtered_accel = low_pass_filter(raw_accel, self.filtered_accel, alpha)

            correction = self.pid.update(self.filtered_accel, dt)
            new_speed = 1000 - correction  # reduce vibration effect
            self.set_motor_speeds(new_speed)
            time.sleep(0.1)

# Run example
drone = Drone()
drone.stabilize()

Output

Motor speed set to: 1000.00
Motor speed set to: 1000.45
Motor speed set to: 999.87
Motor speed set to: 1000.12
Motor speed set to: 999.75
Motor speed set to: 999.90
Motor speed set to: 999.80
Motor speed set to: 999.85
Motor speed set to: 999.88
Motor speed set to: 999.83

Common Pitfalls

Common mistakes when trying to reduce drone vibration include:

• Ignoring hardware issues like unbalanced propellers or loose mounts, which software cannot fix.
• Using too high or too low alpha in low-pass filters, causing either slow response or insufficient smoothing.
• Incorrect PID tuning leading to oscillations or slow correction.
• Not filtering sensor noise before using it in control loops.

python

def low_pass_filter_wrong(current_value, previous_value, alpha):
    # Using alpha=1 means no smoothing, passes raw noise
    return alpha * current_value + (1 - alpha) * previous_value

# Correct usage
filtered_value = low_pass_filter_wrong(sensor_value, last_value, 1)  # wrong
filtered_value = low_pass_filter_wrong(sensor_value, last_value, 0.1)  # right

Quick Reference

• Balance hardware: Check propellers and mounts.
• Filter sensor data: Use low-pass filters with alpha around 0.1.
• Tune PID: Adjust kp, ki, kd for smooth response.
• Test incrementally: Apply changes step-by-step and observe effects.

Key Takeaways

Use low-pass filters to smooth noisy sensor data before control calculations.

Tune PID controller parameters carefully to avoid overcorrection and oscillations.

Ensure drone hardware like propellers and mounts are balanced and secure.

Combine software filtering with hardware fixes for best vibration reduction.

Test changes gradually and monitor drone response to improve stability.