Active Disturbance Rejection Controllers for Speed Control of a PMSM - MATLAB & Simulink
Video Player is loading.
Current Time 0:00
Duration 8:40
Loaded: 0%
Stream Type LIVE
Remaining Time 8:40
 
1x
  • Chapters
  • descriptions off, selected
  • en (Main), selected
    Video length is 8:40

    Active Disturbance Rejection Controllers for Speed Control of a PMSM

    Learn how to implement active disturbance rejection control (ADRC) on a Texas Instruments® C2000™ processor for PMSM speed control. ADRC estimates and compensates for system uncertainties in real time, providing disturbance rejection performance similar to PID controllers but with less tuning effort. This model-free control technique is suitable for addressing challenges when tuning controllers such as uncertain or unmodeled system dynamics and operating regions, sudden load changes, and input voltage fluctuations. Watch the design and implementation process of ADRC using a prebuilt Simulink® block, demonstrating its benefits over PID controllers in the context of PMSM speed control applications.

    Published: 2 Apr 2023

    In this video, we'll look at a speed control of a PMSM model using Active Disturbance Rejection Control. The top level Simulink model shows the plant model, consisting of the motor and inverter blocks from the motor control block set and the cascaded controller setup of the field-oriented controller. Underneath the current control subsystem, the field-oriented control algorithm is implemented using Clarke, park, inverse park, and space vector-generated blocks from the motor control block set.

    The familiar PI controllers here control the d axis and the q axis currents respectively. These PI controllers command the required d and q axis reference voltages to track the current reference. The reference voltages are then subsequently converted to the duty cycles that is fed to the inverter.

    In the outer speed control subsystem, the PI controller commands the q axis reference current to track a specific motor speed reference. Since this system is highly nonlinear because of switching effects of the tuning these PI controllers can be tedious. For such systems, to tune these gains at a particular operating point, one would need to estimate the plan model for each of the loops using either frequency response estimation or input-output test data, and then use the model to tune the PI gains.

    There is extra effort involved if one wants to consider other operating points and account for external disturbances. In such scenarios with these hurdles, ADRC shines through with comparable performance of a PID controller, but with significantly less tuning effort. The pre-built ADRC block in Simulink-controlled design works with the same inputs and outputs as that of a PID controller and has been set up for all the control loops in this model.

    Let's look at how we can set this controller up for the queue access current controller. To determine the model order and the critical gain of the plant, you typically would do an open loop step response test of your plant in the operating range. A point to note here is that the open loop test is just one way to approximate the plan dynamics. You don't have to do it if you have the information or better way of doing it.

    In this scenario, the plan cannot be tested for a purely open-loop response because of stability concerns. So we use PI controller with initial PI gains to operate the plant in a region that is safe and/or stable. When the model is running at 20% of its baseline speed, a step change of around 20 milliwatts to the q axis voltage to the plant brought about a change of around 45 milliamps-- the commanded reference q axis current.

    As you can see here, it's a typical second-order response. So we will choose a second-order approximation. We can then easily determine the critical gain through the second-order approximation shown here.

    The controller bandwidth usually depends on the performance specifications, either in the frequency domain or the time domain. In this example, the controller bandwidth is set to 2,000 pi radians per second. In general, the observer bandwidth is set to 5 to 10 times the controller bandwidth, so that the observer converges faster than the controller. In this case, we have set it to be 8 times the controller bandwidth.

    We'll use the same settings for the d axis current controller. And for the speed loop, we already did a similar step change experiment to determine the model order approximation and the critical gain. The controller bandwidth for the speed loop is set to 200 pi by six radians per second and the observed bandwidth is set to 8 times the controller bandwidth. With the ADRC parameters set, let's set the speed references and see how the ADRC controller performs.

    We command the speed to increase from 0% to 20% of the baseline speed-- the speed at which we tune the ADRC controllers. Then we command it to 90% of the baseline speed, followed by a speed reversal to 80% of the baseline speed. You also have a load torque change at 2 seconds increasing from 5% to 50% of the rate of torque.

    Let's now run the simulation and compare the ADRC controller performance to PID controller. We see that the ADRC controller performs much better than the PID controller with minimal overshoot and similar settling times for all speeds and torque commanded. But the controller tested in simulation, let's now generate code from the model and deploy the target application to the Texas Instruments C2000 processor.

    We have another model which will act as the host and will run on the laptop from which we can set the speed reference in RPM. We also have a capability to switch between PI controller or ADRC controller during the model operation itself. The model here receives signals, such as speed and the currents listed here or serial port from the target application. And we plot per unit normalized values in this scope. Let's start the execution on the host.

    We see the measurements in the scope of the rate. Let's now start spinning the motor using the ADRC algorithm. You see how the motor speed starts tracking the reference. We'll set the motor references to a different speed ranges. I will go up to 90% of the motor baseline speed.

    So let's jump back from 90% to a much lower speed value. You can see how the ADRC performs quite well across different speed ranges with minimal overshoot and quick rise times. Now, we look at the Id current of the motor at different speeds. You'll see that the current is maintained at 0.

    Next, we look at the Iq current for different speeds. And you see how the Iq currents are tracking. And finally, we look at the Ia and Ib, the phase currents of the motor at different speeds. We can also compare the performance of the ADRC controller with that of a PI controller. We see that for the PI controller, there is a much bigger overshoot for different speeds. Of course, yeah, you can tune these PI controllers to have comparable performance as that of an ADRC controller, but that would require significant.

    Let's quickly look at some programming results from the hardware run. These are the execution times for the current controller when using ADRC and PI controllers. We see that both these controllers have similar runtimes of around 13 to 14 microseconds. So there you have it. In this video, you saw how you can design and implement an ADRC controller using a pre-built Simulink block for PMSM motor control application.