Contents:

• Motor Control System Requirements
• NXP i.MX RT1060 Processor
• Advanced PWM for Motor Control
• NXP i.MX RT1060 Eval Kit Setup
• Motor Control Software with Zephyr
• PWM Configuration
• CAN Communication Setup
• Ethernet Communication Setup
• Key Takeaways
• Resources

Modern motor control systems have tough demands. They require precision control, advanced onboard intelligence, and seamless connectivity to larger industrial automation systems.

By leveraging the Zephyr Real-Time Operating System (RTOS), developers can quickly leverage these hardware capabilities. Specifically, Zephyr’s comprehensive driver support and real-time scheduling capabilities, allowing them to focus on their motor control application logic rather than low-level peripheral configuration.

This guide examines the key capabilities of the NXP i.MX RT1060 eval kit and Zephyr RTOS. It demonstrates how to use the platform to implement Field-Oriented Control (FOC), CAN communication, and external connectivity through Ethernet. Finally, it walks through the key steps in configuring and implementing a motor control system.

MOTOR CONTROL SYSTEM REQUIREMENTS

Modern automation systems require a complex array of actuators, sensors, processing, human-machine interfaces, and network communications.

Here, we focus on the requirements for the microcontroller (MCU) and its peripherals. This subsystem needs to meet three key requirements:

1. High-performance motor control using techniques like Field-Oriented Control (FOC), requiring precise PWM timing and real-time processing capabilities for optimal torque and speed control
2. Industrial network integration, particularly through CAN bus, to coordinate multiple motors and integrate with existing automation systems
3. Remote monitoring and control capabilities through standard interfaces like Ethernet, enabling real-time data collection and system management

NXP I.MX RT1060 PROCESSOR

The i.MX RT1060 applications processor can be used in areas such as industrial HMI, IoT, motor control, and home appliances. The flexibility of the architecture enables it to be used in a wide variety of other general embedded applications, too.

The i.MX RT1060 provides a rich feature set for industrial motor control applications. These include:

• 600 MHz Arm Cortex-M7 core for complex control algorithms
• Enhanced FlexPWM modules designed for motor control
• Built-in CAN transceiver for industrial networking
• 10/100M Ethernet for remote monitoring
• Hardware timers for precise control timing

The processor includes many other capabilities that could be useful for network-connected motor control, such as built-in security features.

ADVANCED PWM FOR MOTOR CONTROL

The i.MX RT1060’s enhanced FlexPWM (eFlexPWM) module is specifically designed
for motor control and power conversion applications.

The module provides:

• Four PWM submodules, each capable of controlling one half-bridge power stage
• 16-bit resolution for precise duty cycle control
• Maximum PWM frequency of 150 MHz
• Hardware deadtime insertion with programmable delays
• Fault channel support with programmable polarity and filtering
• Multiple submodule synchronization options for three-phase control
• Each submodule offers a complementary pair of PWM outputs
• Independent or synchronized timebase operation between submodules

These capabilities make the platform particularly well-suited for implementing sophisticated motor control algorithms like FOC, with the precise timing control and protection features needed for reliable operation in industrial environments.

NXP i.MX RT1060 EVAL KIT SETUP

The i.MX RT1060 eval kit provides access to all the key features we discussed earlier, including the enhanced FlexPWM modules, communication interfaces, and real-time processing capabilities.

Key features of the kit include:

• Arduino-compatible headers for connecting motor driver shields
• CAN interface for industrial networking
• Ethernet port for remote monitoring and control
• USB cable for power and programming

To get started:

1. Connect the board to your computer using the USB cable
2. If using a motor driver shield, attach it to the Arduino-compatible headers
3. Configure the board’s boot mode selection switch for your development needs
4. Set up your development environment by downloading the necessary software and tools from NXP’s website

MOTOR CONTROL SOFTWARE WITH ZEPHYR

Once the board is ready to go, set up your Zephyr development environment. Zephyr provides built-in support for the i.MX RT1060, making it straightforward to access the hardware features we need.

These following code samples show the first steps for building a motor control system.
Other steps would typically involve:

1. Implementing the complete FOC algorithm
2. Setting up feedback sensors for position/speed
3. Establishing your communication protocol for control and monitoring
4. Adding safety features and fault handling

In the following code, note that the Zephyr RTOS handles all the low-level hardware initialization and provides a clean API for accessing the i.MX RT1060’s features.

PWM CONFIGURATION

FOC enables precise torque management and efficient operation across a wide range of speeds by controlling the motor’s magnetic field with real-time adjustments to current phase and amplitude.

Zephyr’s real-time capabilities make it well-suited for FOC implementations, ensuring smooth and responsive motor control. Below is a code snippet demonstrating the setup of a PWM signal in Zephyr.

#include <zephyr.h>
#include <drivers/pwm.h>
#define PVM_DEVICE "PWM_0"
#define PVM_CHANNEL 0
void motor_control_task(void) {
const struct device *pum_dev = device_get_binding (PWM_DEVICE);
while (true) <
     pwm_pin_set_usec(pum_dev, PWM_CHANNEL, period, pulse_with,
     PUM_POLARITY _NORMAL);

     K_ sleep(K_MSEC(10));
     }
}

K_ THREAD_DEFINE(motor_control, STACK_SIZE, motor_control_task, NULL, NULL,
NULL, PRIORITY, 0, 0);

CAN COMMUNICATION SETUP

The i.MX RT1060 EVK excels in CAN communication with its integrated FlexCAN modules, offering support for both classic CAN and CAN FD. This flexibility enables higher data throughput, essential for complex industrial networks where multiple devices communicate simultaneously.

Unlike many development kits, the i.MX RT1060 includes built-in CAN transceivers, simplifying the design and reducing the need for additional components, making it an ideal solution for real-time motor control and automation systems.

For industrial networking via CAN:

#include <zephyr.h>
#include ‹drivers/can.h>
#define CAN_DEVICE "CAN_1"
void can_init (void) {
     const struct device *can_dev =
device_get_binding(CAN_DEVICE);
     struct zcan_frame msg;
     msg.id_type = CAN_STANDARD_IDENTIFIER;
     msg.rtr = CAN_DATAFRAME;
     msg.id = 0x123;
     msg.dic = 2U;|
     msg.data[0] = 0xAB;
     msg.data[1] = 0xCD;
     can_send (can_dev, &msg, K_MSEC(100), NULL, NULL) ;
}

K_THREAD_DEFINE(can_thread, STACK_SIZE, can_init, NULL,
NULL, NULL, PRIORITY, 0, 0);

ETHERNET COMMUNICATION SETUP

The Ethernet capabilities of the i.MX RT1060 stand out with its Gigabit Ethernet controller, delivering high-speed, low-latency communication. This is a critical feature for industrial loT applications that require real-time data transmission to remote dashboards or servers.

Notably, the kit supports Time-Sensitive Networking (TSN) standards, ensuring precise handling of time-critical data like motor feedback or sensor updates, making it a robust choice for integrating into modern industrial Ethernet networks.

#include <zephyr.h>
#include <net/socket.h›
#define SERVER_ADDR "192.168.1.100"
#define SERVER_PORT 8080

void ethernet_task(void) ( struct sockaddr_in addr;
int sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP) ;
addr-sin_family = AF_INET;
addr. sin_port = htons (SERVER_PORT) ;
inet_pton (AF_INET, SERVER_ADDR, &addr. sin_addr) ;
connect(sock, (struct sockaddr *)&addr, sizeof(addr) );
     while (true) {
          char msg[] = "Motor status: 0Kn";
          send(sock, msg, sizeof(msg), 0);
          k_sleep(K_SECONDS(1)) ;
     }
}
K_THREAD_DEFINE (eth_thread, STACK_SIZE, ethernet_task, NULL, NULL, NULL, PRIORITY,
0, 8):

KEY TAKEAWAYS

The NXP i.MX RT1060, combined with Zephyr RTOS, offers a powerful platform for industrial motor control applications. This solution stands out for several key reasons:

Hardware Capabilities

• The 600 MHz Arm Cortex-M7 core provides the processing power needed for complex motor control algorithms
• Enhanced FlexPWM modules are specifically designed for motor control applications
• Integrated CAN and Ethernet interfaces enable seamless industrial networking
• Multiple feedback interface options support precise position and speed control

Software Advantages

• Zephyr RTOS provides comprehensive driver support, eliminating the need for low-level peripheral configuration
• Real-time scheduling ensures deterministic control loop timing
• Open-source nature allows for complete system customization
• Strong community support and regular updates

Development Experience

• Arduino-compatible headers on the evaluation board enable rapid prototyping
• Standard debugging interfaces simplify development and troubleshooting
• Rich ecosystem of development tools and examples
• Clear upgrade path from prototype to production

In short, the NXP i.MX RT1060 EVK, integrated with Zephyr OS, is a powerful and flexible platform for developing an advanced industrial motor control and monitoring system.

RESOURCES

• NXP i.MX RT1060 Evaluation Kit Overview: https://www.nxp.com/design/design-center/development-boards-anddesignsi-mx-evaluation-and-development-boards/i-mx-rt1060-evaluation-kit:MIMXRT1060-EVKB
• Getting Started with the MIMXRT1060-EVK: https://www.nxp.com/document/guide/getting-started-with-the-mimxrt1060-evk:GS-MIMXRT1060-EVK?section=plug-it-in
• Zephyr—Supported Features of the MIMXRT1060-EVK: https://docs.zephyrproject.org/latest/boards/nxp/mimxrt1060_evk/doc/index.html