INTRODUCTION
In this module of the 3-Phase PMSM Workshop, the focus is on the hardware and software setups that are going to be used throughout this workshop to implement and test a complete 3-phase Permanent Magnet Synchronous Motor (PMSM) control system with NXP’s S32K micro-controller family. Except for the hardware components that can be purchased from NXP website or various distributors around the world, the software tools used for developing the applications are free of charge.
The following table summarize the most important resources that will be used for reference for upcoming modules:
| S32K144EVB & SoC | DEVKIT MOTORGD |
|
S32K144EVB – Product home page S32K144EVB – Quick Start Guide S32K144 SoC – Reference Manual S32K144 SoC – Data Sheet |
DEVKIT MOTORGD – Product home page DEVKIT MOTORGD – Quick Start Guide MC34GD3000 – Data Sheet PMSM DEVKIT – Product home page |
|
DEVELOPMENT TOOLS |
|
|
MATLAB TOOLBOX for S32K1xx Add-On Installer – MathWorks File Exchange Page FreeMASTER Run-Time Debugging Tool – Product home page S32DS-ARM Design Studio IDE for ARM – Product home page Support & Training – Community page |
|
HARDWARE SETUP
Nowadays, to most common and convenient way to implement the Field Oriented Control (FOC) to control the rotor position in a PMSM is numerical/digital approach. In the distant past like ‘70s & ‘80s most of the applications were developed using analogue techniques which posed a lot of challenges in terms of maintenance and scalability.
Today, we face an abundance of cost effective micro-controller solutions that are reliable, performant and integrates various functionalities that makes engineers life easier than ever. One of such solution is the NXP’s S32K scalable family of AEC-Q100 qualified 32-bit ARM Cortex-M4F and Cortex-M0+ based MCUs targeted for general purpose automotive and high reliability industrial applications.
Due to its low cost, large availability and feature-rich options we choose to implement the motor control solution on NXP’s S32K144EVB Development Kit. As is shown in Fig. 1, this small form factor low cost (US$49) platform is a perfect development system for quick application prototyping and demonstration.
 |
| Fig. 1: S32K144EVB’s components & ports used during the workshop |
The main component of this development platform is the S32K144 MCU that integrates a 32bit Cortex M4F core capable of running at 112MHz with 512KB of Flash memory and 54KB of RAM . Dedicated hardware peripherals for motor control (FTM, ADC, PDB, Timers) and a large collection of communication blocks makes this MCU a suitable candidate for various industrial and automotive applications. A block diagram with the most important components and features is shown in Fig. 2.
In addition to this punchy MCU on the evaluation board we can also find:
- dedicated OpenSDA serial debug interface that will help us debug and visualize the data in real time;
- high speed communication CAN controller that support CAN-FD protocol;
- various interconnect standard headers to interface with other devices;
- analogue and digital inputs/outputs to control the application and/or signal various states;
 |
|
Fig. 2: S32K144 MCU Block Diagram |
The S32K144EVB is design to work in conjunction with various plug in modules the most common one being the DEV-KIT MOTORGD that is designed to offer a low cost (US$49) power inverter solution for PMSM and BLDC motor control applications.
As it is depicted in Fig. 3, the kit can be configured to drive PMSM or BLDC applications with a simple jumper configuration that selects which type of measurements are performed: inverter phase currents for PMSM or Back-EMF voltages for BLDC. A dedicated MOSFET gate driver MC34GD3000 controls the 3-phase inverter that can deliver up to 5Amps RMS on each phase. To address sensor based motor control applications the shield support both HALL or ENCODER type of feedback.
 |
| Fig. 3: DEV-KIT MOTORGD’s components & ports used during the workshop |
To simplify the design process NXP’s is offering a complete out of the box solution for PMSM control application as shown in Fig. 4. The MTRDEVKSPNK144 3-phase PMSM Development Kit with NXP S32K144 MCU is designed to enable rapid prototyping and evaluation of the motor control application without having to wait for the final hardware design.
 |
| Fig. 4: NXP’s MTRDEVKSPNK144 kit used during the workshop |
Anyhow, the workshop is designed to be generic. The only part that is absolutely need it: S32K144 MCU. The Model-Based Design approach and the models we are going to develop throughout this workshop are generic and should help you prototype on any other setup made of power inverter and motor.
SOFTWARE SETUP
NXP offers a wide set of enablement tools and software to help customers to prototype and develop complex applications on top of NPX’s hardware. This workshop keep focus on Model-Based Design prototyping techniques and all the applications that are designed to control the PMSM are developed with NXP’s Model-Based Design Toolbox for S32K1xx. This toolbox is designed to work in conjunction with MATLAB and Simulink tools from MathWorks in order to facilitate fast prototyping and deployment with the help of MATLAB Embedded Coder automatic C-code generation as depicted in Fig. 5.
The generated code is configured to:
- enable special functionalities that are delivered as standard drivers by the NXP’s SDK package for S32K MCU families;
- enable optimized software routines design for motor control supported by NXP’s Automotive Math and Motor Control Library (AMMCLIB);
 |
| Fig. 5: NXP’s Model-Based Design Toolbox SW Architecture Philosophy |
The main advantages of this approach are:
- no longer have to focus on C-code implementation leaving extra time available for algorithm development and research;
- re-use existing standard peripheral initialization code provided via standard SDK;
- re-use special motor control and math functions exposed via AMMCLIB;
- easy to migrate between S32K MCU derivatives to match your own criteria of cost vs. performance;
- simplify the migration between NXP’s platforms that are supported via various Model-Based Design Toolboxes;
- easy to integrate the MATLAB generated code for generic algorithm into a dedicated Integrated Development Environment such as S32 Design Studio;
NOTE: ALL THE SOFTWARE TOOLS USED IN THIS WORKSHOP ARE FREE. SOME OF THE TOOLS REQUIRES A VALID LICENSE THAT CAN BE OBTAINED FREE-OF-CHARGE FROM YOUR NXP ACCOUNT
NXP’s Model-Based Design Toolbox for S32K1xx is delivered as an Add-On package that can be installed automatically in MATLAB. This way MATLAB is going to take care of all installation steps and dependencies. This Add-On can be obtained:
- directly from NXP website: https://nxp.flexnetoperations.com/control/frse/download?element=9501347
- directly from MathWorks website: https://www.mathworks.com/matlabcentral/fileexchange/64740-nxp-support-package-s32k1xx
The easiest way to install the toolbox is to get it directly from MathWorks site via MATLAB Add-Ons Browser as shown in Fig. 6.
 |
| Fig. 6: Browse for Add-Ons in MATLAB |
With a simple search with S32K keyword a list of available toolboxes should become visible. Most likely the first result returned is the NXP Support Package S32K1xx toolbox.
 |
| Fig. 7: Search results |
Select the package and click on Add button to start the installation process.
 |
| Fig. 8: Adding the NXP’s toolbox to your local MATLAB Add-on collection |
After the installation is completed you need to select the Open Folder to change the MATLAB path to navigate to the folder where the toolbox has been installed.
|
|
| Fig. 9: Support Package Install completed |
Execute the Installer.p file to start the Step-by-step Installer Wizard that will configure the rest of the tools on your PC. You need to have an active NXP account to be able to download the packages and generate a license file. The GUI is configured to make your journey simpler.
You need to perform four steps as depicted in Fig. 10:
- download the package: this is semi-automatic since you need to log-in with NXP account to gain access to mltbx package.
- install the package: this is done automatically by MATLAB
- generate the license: this is a manual step. Watch this video to get more details in case you face issues with online documentation from NXP website
- verify the install: this is done automatically by the Installer Guide.
 |
|
Fig. 10: NXP’s Toolbox Installation Guide |
The final step is to configure a compiler tool-chain that will be used to cross-compile from ARM architecture the MATLAB generated code. The actual toolbox for S32K1xx supports GCC, IAR and GreenHills compilers. For convenience, the toolbox is shipped with the free GCC toolchain that is fully supporting the S32K MCU families. To keep things simple and Simulink models available for anyone we are going to configure the GCC as tool-chain that is going to be used for cross-compilation of motor control applications.
Fig. 11 shows the default location of the GCC compiler within the Model-Based Design Toolbox suite and how to create a new System Variable to point to the location of the GCC tool-chain. Please note that the name of the System Variable is defined as: GCC_S32K_TOOL. If you plan to use a different tool-chain please refer to NXP’s Model Based Design Toolbox help that is available directly from MATLAB.
 |
|
Fig. 11: Setting up the GCC tool-chain as compiler for MBD Toolbox |
In addition to the Model-Based Design Toolbox installation and configuration you will need to install the FreeMASTER Run-Time Debugging Tool. The installer can be found in the same Toolbox folder as the GCC tool-chain or it can be downloaded separately from the NXP’s official website. The installation of FreeMASTER is very simple, just run the executable and follow the on the screen instructions.
VERIFICATION
There is no better way to verify something than to create an application. To validate that the hardware and software setup is done correctly and prepared for motor control application development we need to build an example that should validate the following aspects:
- MATLAB code generation: this validates that the NXP toolbox installed correctly, the GCC path and system variable is set correctly, the proper MATLAB licenses exists and are valid
- Application download: this validates that the board is recognized by the Windows OS, the correct OpenSDA USB drivers are installer and configures, the board is alive
- Application running: this validates that the application programmed on the board is executed, the HW inputs and output are operational, the communication with the board is stable
We can test these aspects with a basic application that consists in:
- Read the SW2 push button state at each 0.1 seconds
- Switch on/off the Blue LED
- Record the value of the push button and display its state via serial communication in FreeMASTER
The application flow is shown in Fig. 12. The code that runs on S32K144 MCU will be pooling at each 0.1 seconds the state of the SW2 push button and depending on the value read via the associated digital input will update the state of the Blue LED by writing 1 or 0 to the associated digital output. In the same time the application needs to configure the UART peripheral to send the value of the variable associated with the SW2 push button state to the FreeMASTER where it can be displayed in real time.
 |
| Fig. 12: Basic Application – hardware mapping |
On the S32K144EVB the hardware schematics indicates that the signal from the SW2 push button is routed to the general-purpose pin PTC12. That is the input we are going to use for reading the push button state at each 0.1 seconds.
 |
|
Fig. 13: Push button signal routing |
The Blue LED is associated with the PTD0 general-purpose pin. Each time the SW2 push button will be depressed we need to switch the Blue LED ON.
 |
| Fig. 14: Blue LED signal routing |
To communicate with the S32K144 MCU, we are going to use the built-in OpenSDA that will have a dual purpose: to load/flash the application into the MCU flash memory and to assist with serial communication over the virtual COM port mapped on top of physical USB. For S32K144EVB the MK20 microprocessor that implements the OpenSDA protocol is connected with the S32K144 MCU via RX/TX assigned for UART1 peripheral instance as it is shown in Fig. 15.
 |
|
Fig. 15: Communication between the Host PC and S32K144 MCU |
To get more information about the OpenSDA hardware and software please visit NXP’s OpenSDA webpage.
The entire can be implemented in a matter of minutes using standard Simulink blocks from NXP’s Model Based Design Toolbox for S32K1xx Simulink Library.
 |
|
Fig. 16: NXP’s Model-Based Design Simulink Library |
Check the video below for to see a step-by-step tutorial regarding the implementation details and final setup validation.
| Hands-on video training: How to build an application from scratch with NXP's Model-Based Design Toolbox for S32K MCU family for testing the Hardware and Software environment setup | ||
|---|---|---|
The final model is shown below:
 |
|
Fig. 16: Simulink model to verify the Hardware and Software setup |
When the application is loaded and executed on the target the following result should be visible in FreeMASTER
 |
|
Fig. 17: FreeMASTER variable display |
We hope you enjoy the new workshop format and find this information useful. Feel free to LIKE this article and comment below.
Update revisions:
March 18, 2019
- update the model to work with Model-Based Design Toolbox for MPC57xx Automotive Version 3.0.0 .
May 06, 2020
- update the model to work with Model-Based Design Toolbox for MPC57xx Automotive Version 3.2.0 .
