Generating complementary PWM with adjustable deadtime for the RP2040

Generating complementary PWM with adjustable deadtime for the RP2040

  July 03, 2024    Tahmid

---

I have previously discussed the benefits of using the Raspberry Pi Pico, leveraging the easy-to-program Micropython along with the capable hardware peripherals: 2023 Updates: PhD; Pi Pico and Quick and dirty PIC16F72 programmer with the Pico

Several articles in the blog have previously described applications of PWM in embedded systems, such as Stereo audio player using the PIC32, MCP4822, microSD card and the MDDFS library, DC motor control with PIC16F877A - Practical example of PIC PWM and Generation of sine wave using SPWM in PIC16F684.

Complementary PWM signals with 500ns deadtime

The underlying RP2040 in the Pi Pico provides an easy-to-use and still powerful and flexible set of PWM peripherals that can enable a wide range of applications. A common requirement in power electronics is the generation of complementary PWM signals. For example, the complementary PWM signals are used in a synchronous buck converter, shown below, to drive the switches S1 and S2.

Synchronous Buck Converter
Image source: https://commons.wikimedia.org/wiki/File:300px-Synch_buck.PNG

To prevent shoot-through, a deadtime is employed. Shoot-through is the event when both S1 and S2 are turned on, causing a large current through them due to shorting across the supply voltage. Even if the generated PWM signals are non-overlapping (ie S1 and S2 are never turned on together), delays in the circuitry - through the gate drivers and the power switches themselves - can still result in shoot-through conditions. In a severe case, the shoot-through can cause damage to the switches, blowing them out. In a more moderate case, small overlap times can result in reduced efficiency due to wasted power, but not necessarily damage to the switches. To combat this issue, a deadtime is inserted between the S1 and S2 driving signals. This is an amount of time when both switch control signals are zero allowing for system transients to settle out. How large it should be depends on the circuit parameters and behavior.

In many cases, gate drivers can have built-in features to insert dead-times, such as the LM5106. However, the ability to generate this in the microcontroller itself gives greater flexibility in the selection of gate driver. Further, it allows tuning the time easily in software rather than needing to change hardware components to change deadtimes.

Fortunately, the Pi Pico makes it fairly straightforward to do this!

The details of the PWM peripheral are outlined in the RP2040 datasheet section 4.5. You can find the code sample here: https://github.com/SyedTahmidMahbub/comppwm_rp2040

The corresponding source code is copied below for convenience:

	from machine import Pin, PWM, mem32
	from time import sleep, ticks_ms
	class cpwm():
	def __init__(self, pinA, freq):
	# rely on micropython for initial config
	pwm_pin = PWM(Pin(pinA))
	pwm_pin.freq(freq * 2) # edge freq = 2 * center-aligned
	pwm_pin.duty_u16(0)
	pwm_pin = PWM(Pin(pinA+1))
	pwm_pin.freq(freq * 2) # edge freq = 2 * center-aligned
	pwm_pin.duty_u16(0)
	# slice mapping 4.5.2 in datasheet
	slice_num = (pinA >> 1) if pinA < 16 else ((pinA-16)>>1)
	# reg addr section 4.5.3 in datasheet
	self.PWM_BASE = 0x40050000 + 20 * slice_num
	self.top = mem32[self.PWM_BASE+16] + 1 # period top
	mem32[self.PWM_BASE] = mem32[self.PWM_BASE] | 10 # invert output B, center-aligned
	def duty(self, duty_pc, dt_ticks=0):
	dt_ticks = max(dt_ticks, 0) # ensure non-zero
	duty = int(duty_pc * self.top)
	dutyH = duty & 0xFFFF
	dutymin = min(duty + dt_ticks, self.top)
	dutyL = (dutymin << 16) & 0xFFFF0000
	mem32[self.PWM_BASE+12] = dutyL + dutyH
	# PWM on GP16, GP17
	pwm16 = cpwm(16, 100000)
	# 8 ns per tick for deadtime
	# 63 ticks = 504 ns
	pwm16.duty(0.25, 63)

view raw cpwm.py hosted with ❤ by GitHub

The RP2040 has 8x PWM slices, each with 2 channels. The complementary PWM waveforms are produced on these 2 channels (A and B) on a given slice. The slice to GPIO mapping is shown below.

PWM slice+channel mapping to GPIO pins
Image source: RP2040 datasheet section 4.5.2

The key aspects of the code are:

• Use Micropython to init PWM for the associated GPIO pins (A and B).
• Alter RP2040 registers to configure for complementary PWM. This consists of two settings being changed.
• Invert channel B relative to channel A.
• Use center-aligned (phase-correct) PWM instead of edge-aligned. This ensures that the deadtime is applied to both rising and falling edges of channel A. If edge-aligned PWM was used, the channels would be set high together and the deadtime would only be applied on the falling edge of channel A.
• The deadtime is applied to channel B such that channel A's duty cycle corresponds to the desired/set duty cycle.
• The duty cycles corresponding to both channels A and B are updated with one register write.
• The frequency of the output PWM using center-aligned/phase-correct mode is half that when using the default edge-aligned mode.

An example of phase-correct/center-aligned PWM operation is shown in the figure below, taken from the RP2040 datasheet.

Image source: RP2040 datasheet section 4.5.2.1

To generate the complementary signal on channel B, the duty cycle is computed as the sum of the pulse count corresponding to the desired duty cycle and the desired deadtime ticks. With a 125MHz clock for the RP2040 and default clock/divider settings, this corresponds to 8ns per tick. The inversion of channel B then ensures the production of the desired complementary setting.

Shown below are waveforms for GP16 (PWM 0A) and GP17 (PWM0B) for 100kHz PWM, 25% duty cycle and a 504ns deadtime. The deadtime can be verified by recognizing that it corresponds to one horizontal division, which is set to 500ns.

Complementary PWM signals with 500ns deadtime

Taking a zoomed out view of the waveform highlights the 100kHz frequency and illustrates the complementary PWM generation over multiple cycles, as shown below.

3 cycles of 100kHz PWM complementary signals

A natural use case for this generated complementary PWM signal is to control a synchronous buck converter to achieve high efficiency step down operation. Since Micropython will limit the design of a fast control loop, applications where the high frequency PWM is coupled with a low-bandwidth controller make for a natural home for this use case. A solar MPPT battery charger would make for an ideal usage scenario. Alternately, if the same configuration technique is applied in C, fast control loops can then be designed and implemented.