Module 1: Environment Setup

cancel
Showing results for 
Show  only  | Search instead for 
Did you mean: 

Module 1: Environment Setup

23,666 Views
dumitru-daniel_
NXP Employee
NXP Employee

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. 

 

pastedImage_59.png
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;
pastedImage_68.png

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.

pastedImage_78.png
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.

pastedImage_84.png
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);
pastedImage_95.png
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:

 

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.

pastedImage_107.png
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.

pastedImage_111.png
Fig. 7: Search results

 

Select the package and click on Add button to start the installation process.

pastedImage_117.png
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.

pastedImage_121.png

pastedImage_123.png

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.
pastedImage_2.png

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.

 

pastedImage_4.png

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.

pastedImage_3.png
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.

pastedImage_5.png

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.

pastedImage_8.png
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.

pastedImage_11.png

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.

pastedImage_1.png

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:

pastedImage_3.png

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

pastedImage_5.png

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

May 06, 2020

29 Replies

18,016 Views
palla071
Contributor I

Dear Daniel,

First of all, Thanks for teaching this great course.

I am having few issues while doing the module1. 

First issue:

I could able to generate the code without any errors using the 2019a version. but my kit is not blinking LEd at all while I am pressing sw2. 

Second issue:

 I could successfully map the elf file to free master. But I could not see the sw2 status variable in freemaster. Could you please help me with this. Please see the attached model and generated code. Thanks.

0 Kudos

17,973 Views
mariuslucianand
NXP Employee
NXP Employee

Hello palla071@umn.edu‌,

The project attached has its name on s32k11x but inside the project attached, the Config block gas the target set for S32K144. On which board do you want to run your project? Also, the .mot file attached in the archive  is working on S32K144EVB (Pressing SW2 turns the Blue LED on).

For the second question, please check inside the FreeMaster Config Block the selected UART pins that they have been correctly selected. Please reply with the board you want to run and I will check the pins.

Hope this helps,

Marius

0 Kudos

15,115 Views
palla071
Contributor I

Dear Marius,

Thanks for your response. I am trying to run the code in S32K144EVB. I was using GCC compiler in the files that I have shared. For some reason,it was not working. Then I tried to change the compiler to IAR. Then it started working. Thanks.

2,903 Views
462150318
Contributor I

Hello Dumitru,

 I have encountered a problem while executing the Module 1. The code can be download as the  one shown.  The  code does not executing on MPC5744P DevKit.  Is there a  solution?   PS : I use matlab 2018a and mbd toolbox 3.0.0. 

 Thanks very much and wait for your reply!

 

0 Kudos

2,544 Views
mariuslucianand
NXP Employee
NXP Employee

Hello 462150318@qq.com‌,

I think your post is related, or the same, with the question asked here HotFix: MBD Toolbox 3.0.0 for MPC57xx  so let's discuss your problem here, and not on the Hotfix page.

The MPC board can be programmed using the RappID Bootloader, while the S32K has an alternative option where the code can be programmed by copying the .mot file on the mounted Disk. So, for MPC, once the code was successfully compiled, a popup should appear asking you to reset the board and the bootloader will start transferring the code. Can you confirm this?

If the code was generated and the build was successful, you can also test flashing the generated mot file using the S32DS for Power, and check if the code works. This approach will help us to see if there is a code generation/compiling problem or a flashing issue.

Hope this helps,

Marius

0 Kudos

1,343 Views
ali_terro
Contributor II

Hello Dumitru,

I am facing a Problem while Building the Code. i completed the Installation of the 2018 R1 Toolbox and i am using matlab 2018b but when i build the Code, Simulink freezes and stops working without giving any sort of Output or Errors. have you encoutered this Problem before?

if so please provide me with some Information on how to fix it.

Best Regards

Ali Terro

0 Kudos

1,033 Views
dumitru-daniel_
NXP Employee
NXP Employee

This Simulink model is now available on MATLAB 2018b and MBDT for S32K14x 2018.R1 release

0 Kudos

1,026 Views
rajarama_purani
Contributor I

Hi Dimitri,

Right now I have installed on MATLAB 2019a and can I use the available models?

0 Kudos

973 Views
dumitru-daniel_
NXP Employee
NXP Employee

Simulink  2015b model used in this lecture in case you need to open/import in older MATLAB version.