Field-Oriented Control of PMSM Using Position Estimated by Neural Network on STM32 Processor Based Boards

Model

The example includes the target model pmsm_foc_qep_deep_learning_stm32.

You can use this model to:

This model supports both simulation and code generation.

Target Model Architecture

The following figure shows the architecture of the FOC algorithm that the target model implements:

The model enables you to use either the trained neural network or the quadrature encoder sensor to obtain the rotor position.

As shown in the figure, the neural network uses the Vα, Vβ, Iα, and Iβ inputs to output θe, sinθe, and cosθe, where:

For more details about the per-unit (PU) system, see Per-Unit System (Motor Control Blockset).

Therefore, you must train the neural network using the Vα, Vβ, Iα, Iβ, and θe data so that it can accurately map the inputs into the output and act like a virtual position sensor by estimating the rotor position.

Generate Training Data from Target Simulink Model

The first step to using the example is to generate the Vα, Vβ, Iα, Iβ, and θe data needed to train the neural network, for which you can use the TrainingDataCapture utility function.

This utility function obtains the training data by simulating the target model pmsm_foc_qep_deep_learning_stm32.slx, which contains a quadrature encoder sensor based FOC algorithm.

The function simulates the target model and performs sweep across speed and torque reference values to capture the electrical position as well as the α- and β-equivalents of the stator voltages and currents.

What Is Sweep Operation?

Using sweep operation, the TrainingDataCapture utility function selects a range of different speed-torque operating points, simulates the model (to run quadrature encoder-based FOC) at each operating point (or a reference speed-torque value pair) for a limited time, and records the resulting values of Vα, Vβ, Iα, Iβ, and θe after the stator voltages and currents reach a steady state.

The following figures show the constant blocks that the utility function uses to select each operating point:

After it selects a speed-torque operating point, the utility function uses the subsystem pmsm_foc_qep_deep_learning_stm32/FastTask/FastTask/Subsystem to capture the Vα, Vβ, Iα, Iβ, and θe values (corresponding to this operating point) and record them in a Simulink.SimulationOutput object.

The TrainingDataCapture utility function also manually computes and records the sinθe and cosθe values for this operating point.

Speed Ranges for Sweep Operation

The TrainingDataCapture utility function performs the sweep operation by selecting operating points across the following two speed ranges:

Duration Of Capture for Each Operating Point

The TrainingDataCapture utility function simulates the target model at each speed-torque operating point. After simulation begins for an operating point, the utility function captures the Vα, Vβ, Iα, Iβ, and θe data only for a limited duration defined by these variables:

This approach ensures that the utility function captures data only after the stator currents and voltages reach a steady state (after simulation begins).

You can tune these variables using this live script.

Number of Reference Speed and Torque Data Capture Points

You can also use the following variables to define the number of reference speed and torque data capture points.

Note: Because the utility function uses a relatively fixed torque reference during the zero to low-speed range, the number of reference torque points is fixed in this range.

You can tune these variables using this live script.

Note: The utility function captures, appends, and stores the data for all operating points in the Simulink.SimulationOutput object as shown in the following figure:

Run the following code to generate the training data.

Note: Running the TrainingDataCapture utility function using these parameters can take longer time (approximately three hours).

%% Capture the training data using Simulink Environment
model='pmsm_foc_qep_deep_learning_stm32';
dCStartTime1 = 8; %dataCaptureStartTime for low to high speed
dCEndTime1 = 8.5; %dataCaptureEndTime for low to high speed
dCStartTime2 = 8; %dataCaptureStartTime for zero to low speed
dCEndTime2 = 8.5; %dataCaptureEndTime for zero to low speed
dPSpdLtoH =40; %dataPointsSpeedLowtoHigh
dPSpdZtoL = 100;%dataPointsSpeedZerotoLow
dPTorLtoH =25; %data points torque (low(0.1pu) to high(1pu) speed)
[lowtohighspeeddata,zerotolowspeeddata] = ...
    TrainingDataCapture(model,[dCStartTime1,dCEndTime1],[dCStartTime2,dCEndTime2],...
                        [dPSpdZtoL,dPSpdLtoH,dPTorLtoH]);

The TrainingDataCapture utility function stores the generated data in the following Simulink.SimulationOutput objects:

To access the TrainingDataCapture utility function, click TrainingDataCapture.

Refine and Process Data

The next step is to extract the relevant data from the data you generated in the previous section and then process it.

Extract One Electrical Cycle Data

In the previous section, for each speed-torque operating point, the utility function TrainingDataCapture captured data for multiple electrical cycles during the time interval defined by the variables dCStartTime1, dCEndTime1, dCStartTime2, and dCEndTime2.

This section explains how you can refine the data to extract only one electrical cycle data for each operating point, which the example can use to train the neural network.

Run the following code to extract one electrical cycle information for all operating points.

oneCycleDataLtoH = OneElecCycleExtrac(lowtohighspeeddata);
oneCycleDataZtoL = OneElecCycleExtrac(zerotolowspeeddata);

The utility function OneElecCycleExtrac accepts the Simulink.SimulationOutput objects zerotolowspeeddata and lowtohighspeeddata to return the refined data, which is stored in the following two objects:

To access the OneElecCycleExtrac utility function, click OneElecCycleExtrac.

Concatenate One Electrical Cycle Data

Run the following code to concatenate the extracted data by navigating from zero to low-speed and low to high-speed.

completeData = DataConcatenate(oneCycleDataLtoH, oneCycleDataZtoL);

The utility function DataConcatenate accepts the Simulink.SimulationOutput objects oneCycleDataZtoL and oneCycleDataLtoH to return the concatenated data, which is stored in the Simulink.SimulationOutput object completeData.

To access the DataConcatenate utility function, click DataConcatenate.

Process Concatenated One Electrical Cycle Data

The example splits the data obtained after concatenation into following three data sets:

Run the following code to split the data in the object completeData.

tPLtoH=dPSpdLtoH*dPTorLtoH; % Total data points from speed and torque sweep in the low to high range
tPZtoH=(dPSpdLtoH*dPTorLtoH)+dPSpdZtoL; % Total data points from speed and torque sweep in the zero to high range
[traindatain,traindataout,testdatain,testdataout,validatedatain,validatedataout]...
          = DataPreparation(completeData,tPLtoH,tPZtoH)

The utility function DataPreparation accepts the following arguments:

The function returns the split data, which is stored in the following dlarray objects:

To access the DataPreparation utility function, click DataPreparation.

Train and Test Neural Network

The next step is to select a neural network and train it using the processed data that you generated in the previous section.

This example uses an auto-regressive neural network (ARNN). It uses the following series-parallel architecture.

In the preceding figure:

Therefore, the series-parallel architecture uses the Vα, Vβ, Iα, Iβ, $$\underset{}{\overset{\sim }{\sin }}{\theta }_e$$, and $$\underset{}{\overset{\sim }{\cos }}{\theta }_e$$ inputs to predict the $$\underset{}{\overset{ˆ}{\sin }}{\theta }_e$$ and $$\underset{}{\overset{ˆ}{\cos }}{\theta }_e$$ outputs.

The example provides you with the utility function CreateNetwork to train a neural network and build a non linear ARNN that can estimate rotor position. The utility function CreateNetwork uses the Deep Learning Toolbox object dlnetwork (Deep Learning Toolbox) and function trainnet (Deep Learning Toolbox) to create and train a neural network.

Run the following code to train, test, and validate the neural network.

[net,testdatamse] = CreateNetwork(traindatain,traindataout,testdatain,...
                                 testdataout,validatedatain,validatedataout)

The utility function CreateNetwork accepts the dlarray objects traindatain, traindataout, testdatain, testdataout, validatedatain, and validatedataout to return the trained neural network (ARNN) as well as the mean-square error information, which is stored in the following object and variable:

To access the CreateNetwork utility function, click CreateNetwork.

For more details about the training process, see Building Neural Network for Virtual Position Sensing.

Export Trained Neural Network to Target Simulink Model

After you train the neural network, the next step is to export the trained ARNN to a Simulink model.

The CreateNetwork utility function generates a trained ARNN that contains two fully connected layers and an activation layer. The following figure shows the code snippet that defines the neural network layers.

Note: The example uses the exportNetworkToSimulink function from Deep Learning Toolbox to export the trained ARNN network (net) to the Simulink layers blocks so that you can use the network for simulation and code generation.

Run the following command to execute the function.

exportNetworkToSimulink(net)

The function accepts the dlnetwork object net to create the Simulink layers blocks in a new Simulink model as shown in the following figure:

Copy these layers blocks and add them to the subsystem pmsm_foc_qep_deep_learning_stm32/FastTask/FastTask/Neural Network Observer/Neural Network/NN_Model_ARNN (available in the the target model pmsm_foc_qep_deep_learning_stm32.slx) as shown in the following figure:

The following figures show the resulting architecture of the ARNN that acts as a virtual position sensor. To achieve good performance with timeseries predictions, the example provides the previous output values (sinθe and cosθe) as additional inputs (with a delay).

Note: The model pmsm_foc_qep_deep_learning_stm32.slx provides you with the option to switch between neural network-based or quadrature encoder-based position sensing.

Simulate and Deploy Code

After you export the neural network to Simulink, run the following command to open the updated target Simulink model.

open_system('pmsm_foc_qep_deep_learning_stm32.slx');

Simulate Model

Follow these steps to simulate the model.

1. In the Position sensing type section of the target model pmsm_foc_qep_deep_learning_stm32.slx, select one of the following options:

2. Click Run on the Simulation tab to simulate the model.

3. Click Data Inspector on the Simulation tab to view and analyze the simulation results.

The following figure shows the comparison between the position obtained using quadrature encoder sensor and the position estimated by the trained neural network.

Required Hardware

Model to Target Hardware