3-Phase Inverter using ESP32 SPWM Generator

• I. Introduction
  • Explanation of DC to AC 3-phase inverters
  • A brief overview of using the ESP32 MCPWM peripheral for 3-phase SPWM generation
• II. Circuit Design
  • 3-phase H-Bridge MOSFET (Six-switch configuration)
  • 3-Phase transformer
  • ESP32 3-phase SPWM module
  • PCB Layout design
• III. MCPWM Configuration
  • MCPWM peripheral and its configuration
  • Initialization of the MCPWM module
  • Setting the PWM configuration for each channel
  • Configuring the pins for output
  • Configuring Interrupt Routine
• IV. 3-Phase SPWM Signal Generation
  • Explanation of carrier and modulating waveforms
  • Generating modulating waveform using a lookup table or mathematical function
  • Combining carrier and modulating waveforms to generate 3-phase SPWM signals
• V. Experimental Results
  • Test Setup
  • Measuring output voltage and frequency with oscilloscope and frequency counter
• VI. Conclusion
• VII. Future Developments

I. Introduction

In this project, my goal is to design a three-phase SPWM generator using an ESP32 MCPWM peripheral. I aim to gain a solid understanding of how to generate SPWM signals for three-phase applications using the ESP32. This will involve exploring the capabilities of the MCPWM peripheral and designing a DC-to-AC inverter circuit. Ultimately, I hope to build a reliable and effective 3-phase inverter using the esp32.

Explanation of DC to AC 3-phase inverters

DC to AC 3-phase inverters are electronic devices that convert DC power to AC power with a 3-phase output. It can then power three-phase AC loads such as motors and others.

In a typical DC to AC 3-phase inverter, a DC input is fed into a six-switch power electronic circuit. This switches the DC voltage on and off rapidly to produce a series of voltage pulses.
After filtering, the system directs these voltage pulses into a transformer, which then converts the voltage into 3-phase AC power.

By adjusting the duty cycle of the six-switch circuit, one can effectively control the frequency and amplitude of the AC output. The output waveform can be either sinusoidal or modified to suit the specific application requirements.

DC to AC 3-phase inverters have a wide range of applications, including renewable energy, electric vehicles, and industrial power systems. They are often used in situations where AC power is required, but only DC power is available.

A brief overview of using the ESP32 MCPWM peripheral for 3-phase SPWM generation

The ESP32 is a powerful microcontroller that includes a Multi-Channel Pulse Width Modulation (MCPWM) peripheral for generating high-frequency PWM signals. The ESP32’s MCPWM peripheral offers the capability to generate SPWM signals, enabling its use in driving 3-phase inverters.

SPWM (Sine Pulse Width Modulation) is a technique used to generate a series of PWM signals whose duty cycle is modulated by a sine wave. The SPWM signals are then used to drive the 3-phase inverter to generate 3-phase AC output.

With the ESP32 MCPWM peripheral, there are six channels available for utilization, specifically designed for generating 3-phase SPWM signals. Each of these channels has the capability to generate two PWM signals, each with distinct duty cycles. These PWM signals play a crucial role in controlling the switches of the inverter.

The ESP32 MCPWM peripheral has many features that make it suitable for 3-phase SPWM generation. These include programmable frequency, duty cycle, dead time, and phase shift for each channel, as well as the ability to configure the output pins for PWM signal generation.

Using the ESP32 MCPWM peripheral for 3-phase SPWM generation simplifies the hardware design and reduces the number of external components required. Additionally, the ESP32 offers a flexible and powerful platform for controlling and monitoring the inverter system through its built-in WiFi, Bluetooth, and other communication interfaces.

Overall, using the ESP32 MCPWM peripheral for 3-phase SPWM generation provides a cost-effective and efficient solution for driving 3-phase inverters in a variety of applications.

II. Circuit Design

In this section, we will discuss the design of a 3-phase inverter circuit using a six-switch configuration and ESP32 3-phase SPWM card.

3-phase H-Bridge MOSFET (Six-switch configuration)

The six-switch configuration is the most commonly used topology for 3-phase inverters. It consists of six power switches, which are arranged in three pairs of complementary switches. The three pairs of switches are connected to the three-phase load, and the DC voltage source is connected to the midpoint of the three-phase load. The switches are controlled by a sinusoidal pulse width modulation (SPWM) signal, which determines the frequency and amplitude of the AC output voltage.

The circuit below is the circuit for the 3-Phase H-Bridge MOSFET used in this project. The circuit with the blue background is the circuit that I prepared for the next development and is currently not used.

The most commonly used topology for 3-phase inverters is the six-switch configuration. It comprises six power switches arranged in three pairs of complementary switches. The three pairs of switches connect to the three-phase load, while the midpoint of the three-phase load connects to the DC voltage source. A sinusoidal pulse width modulation (SPWM) signal controls the switches, determining the frequency and amplitude of the AC output voltage.

This project utilizes the circuit below, which represents the circuit for the 3-Phase H-Bridge MOSFET. The circuit with the blue background is currently not in use, the one I prepared for the next development.

Please note the component on the top left is a DC-DC converter XL7015 and needs to set the output at 12Vdc before installing the 3-phase SPWM module

3-Phase transformer

It is possible to use three single-phase transformers to create a three-phase transformer with a delta configuration at the primary and a star configuration at the secondary. The delta-star transformer is a common reference for this configuration.

Each transformer’s primary winding connects in a delta configuration, forming a loop where each end of the winding connects to the start of the next winding. The connection points of the windings receive the three-phase supply voltage.
In the secondary winding of each transformer, a star configuration is used. This configuration connects the three ends of the windings to create a neutral point, while the remaining three ends produce the three-phase output voltages.
Making a neutral connection at the secondary winding is one of the main advantages of this configuration, providing the benefit of having a neutral point available. This feature proves useful in applications that necessitate a neutral connection.
Another advantage is that it can be more cost-effective to use three single-phase transformers instead of a single three-phase transformer, especially for lower-power applications.

ESP32 3-phase SPWM module.

The circuit depicted below represents the ESP32 3-Phase SPWM Generator utilized in this project. The circuit featuring the blue background corresponds to the circuit prepared for future development and is presently inactive.

This SPWM generator circuit uses the ESP32 DEVKIT-V1 with TLP250 as the High Side and Low side Drivers. For the purposes of High-Side and Low-Side drivers can also use other types of drivers such as IR2110 and so on.

PCB Layout design

For this project, I’m still making a single-layer PCB layout so I can print it myself.

PCB Layout 3-phase H-Bridge MOSFET

PCB Layout ESP32 3-phase SPWM module

III. MCPWM Configuration

MCPWM peripheral and its configuration

To configure the MCPWM peripheral as the 3-phase SPWM generator, you would typically need to set the following parameters:

Clock source: You can determine the PWM frequency by selecting a clock source, which can be either the system clock or an external oscillator.

PWM mode: The PWM mode determines the frequency and duty cycle of the PWM signals. Edge-aligned and centre-aligned are the two most common PWM modes.

Output polarity: You can choose the output polarity to be either active high or active low.

Initialization of the MCPWM module

First, We need to include the MCPWM library by adding the following line at the top of your code:

#include "driver/mcpwm.h"

Setting the PWM configuration for each channel

Next, you need to configure the MCPWM module by creating a mcpwm_config_t object and setting its parameters.

  mcpwm_config_t pwm_config;
  pwm_config.frequency = freqCarr * 2 ;             
  pwm_config.cmpr_a = 0;                            
  pwm_config.cmpr_b = 0;                            
  pwm_config.counter_mode = MCPWM_UP_DOWN_COUNTER;  
  pwm_config.duty_mode = MCPWM_DUTY_MODE_0;         
  mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config); 
  mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_1, &pwm_config);   
  mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_2, &pwm_config); 

This code is configuring and initializing the MCPWM module on the ESP32 microcontroller to generate three PWM signals using three timers: MCPWM_TIMER_0, MCPWM_TIMER_1, and MCPWM_TIMER_2. Here’s what each line of the code does:

mcpwm_config_t pwm_config;

This creates a structure of type mcpwm_config_t called pwm_config that will hold the configuration parameters for the MCPWM module.

Frequency

pwm_config.frequency = freqCarr * 2;

This sets the frequency of the PWM signals to freqCarr * 2, which is twice the carrier frequency. The carrier frequency must be multiplied by two regarding the MCPWM_UP_DOWN_COUNTER mode used.

Initial DutyCycle

pwm_config.cmpr_a = 0;
pwm_config.cmpr_b = 0; 

This sets the duty cycle of PWM signals A and B to 0%, which means that the PWM signal will be low all the time.

Counter Mode

pwm_config.counter_mode = MCPWM_UP_DOWN_COUNTER; 

This sets the counter mode of the timer to up-down counter mode, which means that the timer will count up to the maximum value and then count down to 0, creating a symmetric PWM signal. As a result, the actual frequency will be half of the defined.

Duty Mode

pwm_config.duty_mode = MCPWM_DUTY_MODE_0;

This sets the duty cycle mode to MCPWM_DUTY_MODE_0, which means that the duty cycle is represented as Active high duty, i.e. duty cycle proportional to high time.

Initialize Timer_X to MCPWM_0

mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config);
mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_1, &pwm_config);
mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_2, &pwm_config);

This initializes the MCPWM module on MCPWM_UNIT_0 (which is the only unit available on the ESP32) using MCPWM_TIMER_0, MCPWM_TIMER_1, MCPWM_TIMER_2 and the configuration parameters in the pwm_config structure.

Initializing this timer produces a PWM carrier frequency that is not exactly what I expected, there is a deviation of several hundred Hertz at the output. When I wrote this post, I still don’t know exactly which part is not appropriate. In the meantime, I’m trying to reinitialize some of the registers that might be causing this, like the code below.

  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0, 0);                  // PWM_CLK_CFG_REG 
  WRITE_PERI_REG(DR_REG_PWM0_BASE + 4, tmrRegVal << 8);     // PWM_TIMER0_CFG0_REG 
  WRITE_PERI_REG(DR_REG_PWM0_BASE + 14, tmrRegVal << 8);    // PWM_TIMER0_CFG1_REG 
  WRITE_PERI_REG(DR_REG_PWM0_BASE + 24, tmrRegVal << 8);    // PWM_TIMER0_CFG1_REG 

In this way the output frequency of the PWM is what I expected and without any frequency deviation.

Overall, this code initializes the MCPWM module to generate three PWM signals with a frequency of freqCarr * 2 and a duty cycle of 0%. To generate the three PWM signals, three timers are utilized in up-down counter mode. This configuration ensures the creation of symmetric PWM signals. The provided code can serve as a foundational framework for generating sinusoidal PWM signals. It enables the adjustment of parameters, such as the duty cycle and other factors, through sinusoidal calculations.

Configuring the pins for output

I used mcpwm_gpio() function to initialise pins for the output signals of MCPWM module.

  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, LO1);   // Use GPIO 12 for MCPWM0A
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0B, HO1);   // Use GPIO 13 for MCPWM0B
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM1A, LO2);   // Use GPIO 12 for MCPWM0A
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM1B, HO2);   // Use GPIO 13 for MCPWM0B
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM2A, LO3);   // Use GPIO 12 for MCPWM0A
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM2B, HO3);   // Use GPIO 13 for MCPWM0B

The function takes three arguments:

The first argument is the MCPWM unit number, which specifies which MCPWM module will be used. In this case, MCPWM_UNIT_0 is used.

The second argument is the MCPWM signal type, which specifies whether the pin will be used for MCPWM0A, MCPWM0B, MCPWM1A, MCPWM1B, MCPWM2A, or MCPWM2B. These signals correspond to the output signals of the three timers in the MCPWM module. In this code, all six signals are initialized.

The third argument of the function represents the GPIO pin number assigned for the corresponding MCPWM signal type. For instance, in the first line of the code, “LO1” corresponds to GPIO pin 12, which will be utilized for the MCPWM0A signal.

Here I use six GPIO ports to serve six MOSFET switches in a 3-Phase H-Bridge MOSFET circuit. It’s important to ensure that the selected GPIO pins are capable of outputting PWM signals and that they are not being used for other purposes.

Configuring Interrupt Routine

mcpwm_isr_register(MCPWM_UNIT_0, MCPWM_ISR, NULL, ESP_INTR_FLAG_IRAM, NULL);
WRITE_PERI_REG(DR_REG_PWM0_BASE + 110, BIT(3));    // INT_ENA_PWM_REG enable 

The code above will call an interrupt routine called MCPW_ISR every time the timer goes to zero. The MCPWM_ISR routine itself contains code to update the pulse width value which I will discuss next.

IV. 3-Phase SPWM Signal Generation

This project is a continuation of the previous project, namely the ESP32 SPWM generator, which generates SPWM signals for one phase. Thus the coding for this 3-phase project is a development rather than a single-phase project. As a comparison, please see the previous post, namely ESP32 MCPWM as SPWM generator.

Explanation of carrier and modulating waveforms

The generation of SPWM signals is the result of modulating a carrier signal with a modulation signal using the same method as in the single-phase project. The carrier signal I am currently using also has a frequency of 20 kHz, so the Timer initialization remains the same as in the single-phase project.

To generate 3-phase SPWM signals, three PWM signal sources with triangular carrier signals are required. For this purpose, the MCPWM_UP_DOWN_COUNTER mode is selected on the timer to generate the triangular signal virtually.

The modulation signal is a sinusoidal signal with a frequency of 50 Hz or 60 Hz, which will modulate the PWM signal by changing its duty cycle, not its amplitude. Similarly, this sinusoidal signal is a virtual signal generated by calculations. In a 3-phase system, the modulation signal has a phase difference of 120 degrees.

Generating modulating waveform using a lookup table or mathematical function

We can perform modulation of the carrier signal in two ways, either using a Lookup Table or by using a mathematical function.

In this project, I am using a mathematical function to modulate the PWM signal. My consideration for using a mathematical function is to anticipate the possibility of requiring variable frequency in the future.

The mathematical modelling of SPWM can be applied by using the following formula:

V_(i) = Vm * sin (2 * π * f * t_i)
where,
V_(i) = reference sinusoidal AC signal
Vm = amplitude of the reference signal
f = frequency of the reference signal
t_i = i times the period of the carrier signal ( 1/f_carr * i )

To generate a 3-phase signal, I use this function by providing a phase difference of 120 degrees for each phase by adjusting the value of t_i.

Combining carrier and modulating waveforms to generate 3-phase SPWM signals

To obtain a 3-phase SPWM signal, I need to combine two signals: the desired signal and the carrier signal. Here’s the approach I have implemented:

• Run the MCPWM function as an Interrupt Service Routine (ISR), causing an interrupt to occur at regular intervals. For example, if the carrier frequency is 10 kHz, an interrupt will occur every 100 microseconds.
  During the initialization process, define an ISR (Interrupt Service Routine) function named “MCPWM_ISR.” This function will be executed at regular intervals, such as every 100 μs.
• Perform mathematical calculations for generating sinusoidal waveforms for the three phases within the ISR function. The calculated values are then used to update the PWM pulse width.
  As a result, the PWM pulse widths PWM0x, PWM1x, and PWM2x will change dynamically at each interval.

By combining the carrier signal and the modulating signal through this process, I generate a new PWM signal. This PWM signal has a frequency of 10 kHz, and I modulate its pulse widths using a 50 Hz sinusoidal waveform. To generate a 3-phase signal, within the ISR, I perform three sinusoidal calculations with a phase difference of 120 degrees between them.

By following these steps, I combine the carrier signal and the modulating signal to produce a new PWM signal. Consequently, I achieve the generation of a 3-phase SPWM signal. This signal operates at a carrier frequency of 10 kHz and undergoes modulation of its pulse widths by a 50 Hz sinusoidal waveform. Additionally, I ensure that the three phases of the signal maintain a constant phase difference of 120 degrees between them.

Sine Calculation

  sineValue_0 =  amplitude * sin (radVal * i);
  sineVal_0 = int (sineValue_0);  

  sineValue_120 =  amplitude * sin (radVal * (i + offset120));
  sineVal_120 = int (sineValue_120);  

  sineValue_240 =  amplitude * sin (radVal * (i + offset240));
  sineVal_240 = int (sineValue_240);    

The code above performs sinusoidal calculations for three phases, with each phase having a phase difference of 120 degrees. Even though the formula used is different from the formula I wrote earlier, it still has the same mathematical function, it’s just that the value I entered is in radians instead of frequency.

Duty Cycle Update

  if (sineVal_0 == 0)   WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0040, 0);  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0044, 0);  
  if (sineVal_0 > 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0040, sineVal_0);         
  if (sineVal_0 < 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0044, abs(sineVal_0));         

  if (sineVal_120 == 0) WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0078, 0);  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x007C, 0);           
  if (sineVal_120 > 0)  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0078, sineVal_120);         
  if (sineVal_120 < 0)  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x007C, abs(sineVal_120));           

  if (sineVal_240 == 0) WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B0, 0);  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B4, 0);           
  if (sineVal_240 > 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B0, sineVal_240);         
  if (sineVal_240 < 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B4, abs(sineVal_240));

And the code above is the code where modulation takes place. The calculated sinusoidal values for each phase are stored in registers to update the pulse width for use in the next interrupt.

The pulse width will change if we change the duty-cycle value. In generating SPWM, this duty-cycle value always changes at any time based on a predetermined time. To change the pulse width at a certain time, I do this update on the interrupt routine that occurs according to the time of the timer period.

As a result, the pulse widths of PWM0, PWM1, and PWM2 will represent the pulse widths for signals with a phase difference of 120 degrees.

Here is the complete ISR code:

void IRAM_ATTR MCPWM_ISR(void*) { 
  float sineValue_0, sineValue_120, sineValue_240;
  int sineVal_0, sineVal_120, sineVal_240;

  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x011C, BIT(3));            // INT_CLR_PWM_REG // clear interrupt  
   
  sineValue_0 =  amplitude * sin (radVal * i);
  sineVal_0 = int (sineValue_0);  
  sineValue_120 =  amplitude * sin (radVal * (i + offset120));
  sineVal_120 = int (sineValue_120);  
  sineValue_240 =  amplitude * sin (radVal * (i + offset240));
  sineVal_240 = int (sineValue_240);       

  if (sineVal_0 == 0)   WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0040, 0);  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0044, 0);  
  if (sineVal_0 > 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0040, sineVal_0);         
  if (sineVal_0 < 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0044, abs(sineVal_0));         

  if (sineVal_120 == 0) WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0078, 0);  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x007C, 0);           
  if (sineVal_120 > 0)  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x0078, sineVal_120);         
  if (sineVal_120 < 0)  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x007C, abs(sineVal_120));           

  if (sineVal_240 == 0) WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B0, 0);  WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B4, 0);           
  if (sineVal_240 > 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B0, sineVal_240);         
  if (sineVal_240 < 0)    WRITE_PERI_REG(DR_REG_PWM0_BASE + 0x00B4, abs(sineVal_240));           
         
  i++;
  if (i > sampleNum ) i=0;                      // reset i if > 1 cycle    
}

Please note that when calculating the sinusoidal values for a range of 360 degrees, positive values are obtained for 0 < degrees < 180, negative values for 180 < degrees < 360, and zero for degrees = 0 or 180.

When the sinusoidal calculation result is zero, the pulse width for PWMxA and PWMxB is set to zero. When the calculation result is positive, PWMxA has a pulse width equal to that value while PWMxB remains at zero. Conversely, when the calculation result is negative, PWMxB has a pulse width equal to that value while PWMxA remains at zero.

V. Experimental Results

Test Setup

The purpose of the test I conducted was to observe the results of generating the 3-phase SPWM signal along with the six-switch H-bridge configuration. The focus of this experiment was on the quality of the sinusoidal signal and the phase differences produced.

To test this, I used three single-phase transformers with a rating of 7.5V/220V and 200mA. In this test, I did not test the power with a load, so I believe the small transformers are sufficient for testing purposes. The modulation index I used in the code for this experiment was 0.9.

Measuring output waveform and frequency.

The test that I did as above gave the result of a sinusoidal waveform as below:

The measured voltages in this configuration are 54V for phase to neutral and 92V for phase to phase.
The frequency generated matches the planned frequency of 50 Hz.

The measurement of the phase difference is as follows:

As for the measurement of phase differences, the first image shows a phase difference of 6.6 mS or 120 degrees between phase 1 (yellow) and phase 2 (blue). The second image shows a phase difference of 13.4 mS or 240 degrees between Phase 1 (yellow) and Phase 3 (blue).

VI. Conclusion

The ESP32 MCPWM peripheral, with its programmable features and multiple channels, is well-suited for generating SPWM signals to drive the inverter.

The project involved designing the necessary circuitry, including the 3-phase H-Bridge MOSFET configuration, 3-phase transformer configuration, and the ESP32 3-phase SPWM module. PCB layouts were created for both the H-Bridge MOSFET and the SPWM module.

The MCPWM peripheral was configured to generate the SPWM signals. The frequency, duty cycle, counter mode, and duty mode of each channel were set using the MCPWM library. The pins for output signals were initialized using the mcpwm_gpio_init() function. An interrupt routine was also registered to update the pulse width values.

The generation of the 3-phase SPWM signals involved modulating a carrier signal with a sinusoidal modulation signal. The carrier signal was generated using the MCPWM_UP_DOWN_COUNTER mode, while the modulation signal was calculated based on the desired frequency. The duty cycle of the PWM signals was adjusted based on the modulation signal to achieve the desired SPWM output.

Overall, this project aimed to create a reliable and effective solution for generating 3-phase SPWM signals using the ESP32 MCPWM peripheral. The design and implementation of the circuitry, along with the configuration of the MCPWM peripheral, were key steps in achieving this goal. The resulting solution offers a cost-effective and efficient approach for driving 3-phase inverters, making it suitable for a wide range of 3-phase applications.

VIII. Future Developments

In this project I fully focus on generating SPWM, to make a good 3-phase inverter still requires a number of things such as:

• Add closed-loop control with feedback sensors for improved accuracy and stability.
• Add fault detection and diagnostic algorithms to enhance system reliability and facilitate troubleshooting.
• Explore networking options like Wi-Fi or Ethernet for seamless integration into IoT systems.