# Designing and Analyzing PD and Full State Feedback Controllers for Drone Trajectories

August 31, 2024
Dr. Alex Thompson
Australia
Control System
Dr. Alex Thompson, with over 12 years of experience in control systems and robotics, earned his Ph.D. in Engineering from the University of Adelaide, Australia.

In today's rapidly advancing world, drones have emerged as a pivotal technology with applications spanning various industries, from agriculture to logistics and beyond. One of the fascinating aspects of drones is their control systems, which require precise tuning to ensure that they can follow a designated path or perform specific maneuvers. If you’re a student tackling a MATLAB assignment on drone control systems, you might be asked to design controllers such as Proportional-Derivative (PD) controllers or Full State Feedback controllers to achieve specific trajectories.

These assignments can be complex, but with a structured approach, they become manageable and even enjoyable. This blog will guide you through the process of solving such assignments, helping you understand the essential principles and methodologies involved. Whether you're dealing with the design of controllers, simulation of drone trajectories, or analysis of system stability, this guide will provide the insights you need to excel.

## Understanding the Problem Statement

Before diving into the technical aspects, it’s crucial to understand the problem statement thoroughly. Typically, in a drone control system assignment, you’ll be given a reference trajectory that the drone is supposed to follow. Your task is to design a controller that ensures the drone follows this trajectory as closely as possible.

### Breaking Down the Problem:

• Reference Trajectory: The reference trajectory is the desired path that the drone needs to follow. In the example given, the drone must move from its initial position to a series of positions at specified intervals and maintain those positions for certain durations. Understanding the nature of this trajectory is the first step in designing an effective control system.
• Controller Design: Depending on the problem, you may need to design different types of controllers, such as PD controllers or Full State Feedback controllers. Each controller has its unique characteristics and is suitable for different scenarios.
• System Response: You’ll likely need to analyze the system’s response to various inputs, such as a step input, and compare how different controllers perform in maintaining the desired trajectory.

By clearly understanding these elements, you set the stage for a successful assignment. The next step is to start the design process.

## Designing a PD Controller

The Proportional-Derivative (PD) controller is one of the most commonly used controllers in control systems. It’s relatively simple to design and implement, making it an excellent choice for many trajectory-following tasks. Here’s how you can approach the design of a PD controller in MATLAB:

1. Determine the Control Gains (k_p and k_d): The PD controller works by adjusting the control input based on the current error (the difference between the desired position and the actual position) and the rate of change of this error. The two main parameters you need to tune are the proportional gain (kpk_pkp) and the derivative gain (kdk_dkd).

• Proportional Gain (kpk_pkp): This gain determines how aggressively the controller responds to the current error. A higher kpk_pkp will cause the drone to correct its position more rapidly but can also lead to overshoot if set too high.
• Derivative Gain (kdk_dkd): This gain controls the rate of change of the error. It helps in damping the system response and reducing overshoot.

In MATLAB, you can start by choosing initial values for kpk_pkp and kdk_dkd based on your understanding of the system dynamics. You can then use MATLAB’s pidTuner tool to fine-tune these values. The tool allows you to interactively adjust the gains and observe the effects on the system’s response in real-time.

2. Simulate the Drone’s Response: Once you have your initial gains, it’s time to simulate the system. MATLAB provides powerful tools for simulation, such as Simulink, which allows you to model the drone’s dynamics and the PD controller’s behavior.

• Modeling the System: Start by creating a model of the drone’s dynamics in Simulink. This model should include the forces acting on the drone, its inertia, and any other relevant dynamics.
• Implementing the PD Controller: Add the PD controller to your Simulink model. The controller should take the error signal as input and output the control signal that drives the drone’s actuators.
• Running the Simulation: Run the simulation and observe the drone’s trajectory. Ideally, the drone should follow the reference trajectory closely. If there’s significant deviation, you may need to adjust the kpk_pkp and kdk_dkd values.

3. Analyze Stability and Performance: After running the simulation, the next step is to analyze the system’s stability and performance. MATLAB offers several tools to help with this, including the pzmap function, which plots the poles and zeros of the closed-loop system.

• Stability Analysis: Check the location of the poles of the closed-loop system. For the system to be stable, all poles should be in the left half of the complex plane. If any poles are in the right half-plane, the system is unstable, and you’ll need to retune your controller.
• Performance Metrics: Evaluate the performance of the PD controller using metrics such as overshoot, settling time, and steady-state error. MATLAB’s stepinfo function provides these metrics automatically, helping you assess how well your controller performs.

Through these steps, you can design and implement a PD controller that effectively guides the drone along the desired trajectory. However, in some cases, a more advanced control strategy, such as Full State Feedback control, may be necessary.

## Implementing Full State Feedback Control

Full State Feedback control is a more sophisticated method that allows for precise control over the entire state of the system. This approach is particularly useful when you need to control multiple aspects of the drone’s behavior simultaneously.

1. Formulate the State-Space Model: The first step in implementing Full State Feedback control is to formulate the state-space model of your system. The state-space model represents the system dynamics using matrices, typically labeled AAA, BBB, CCC, and DDD.

• State Variables: Identify the state variables that describe the system’s behavior. For a drone, these might include position, velocity, and orientation.
• System Matrices: Define the system matrices AAA, BBB, CCC, and DDD based on the system’s dynamics. The AAA matrix describes the system’s internal dynamics, the BBB matrix represents how control inputs affect the system, the CCC matrix maps the state variables to the system’s outputs, and the DDD matrix represents direct feedthrough (often zero in many systems).

Once you have the state-space model, you can proceed to design the Full State Feedback controller.

2. Design the Controller Using Pole Placement: Pole placement is a method used to design a Full State Feedback controller by placing the poles of the closed-loop system at desired locations in the complex plane. This allows you to shape the system’s response to meet specific performance criteria.

• Choose Desired Pole Locations: The desired pole locations should be chosen based on the performance requirements, such as desired settling time, damping ratio, and natural frequency.
• Calculate the Gain Matrix KKK: Use MATLAB’s acker function to calculate the gain matrix KKK that places the poles of the closed-loop system at the desired locations. The gain matrix is then used in the state feedback law u=−Kxu = -Kxu=−Kx, where uuu is the control input and xxx is the state vector.

3. Verify Controllability and Observability: Before finalizing the controller design, it’s essential to verify that the system is both controllable and observable. Controllability ensures that you can drive the system to any desired state using the available inputs, while observability ensures that you can reconstruct the state of the system from the outputs.

• Controllability Check: Use MATLAB’s ctrb function to compute the controllability matrix and check its rank. If the rank is equal to the number of state variables, the system is controllable.
• Observability Check: Similarly, use MATLAB’s obsv function to compute the observability matrix and check its rank. If the rank is full, the system is observable.

If the system is not controllable or observable, you may need to reconsider your choice of state variables or the design of your controller.

## Step Response and System Behavior

A critical part of any control system analysis is understanding how the system responds to a step input. The step response provides valuable insights into the system’s behavior, such as how quickly it reaches the desired position and how much it overshoots before settling.

1. Simulate the Step Response: To simulate the step response in MATLAB, you can use the step function. This function applies a step input to your system and plots the response over time.

• PD Controller Step Response: For the PD controller, the step response will show how quickly the drone responds to sudden changes in the reference position. Ideally, the response should be fast with minimal overshoot.
• Full State Feedback Controller Step Response: The step response for the Full State Feedback controller should show a more refined control, with even faster settling times and reduced overshoot compared to the PD controller.

2. Compare Controllers: After simulating the step responses for both controllers, compare their performance:

• Settling Time: How quickly does each controller bring the drone to the desired position?
• Overshoot: Does the drone overshoot the target position? If so, by how much?
• Steady-State Error: Does the drone eventually reach and stay at the desired position, or is there a persistent error?