Configuring PCNT for Quadrature Encoder Feedback

1. Understanding Quadrature Encoders

A rotary encoder is a sensor that translates the angular position of a shaft into a digital signal. For motor control, we most commonly use incremental quadrature encoders. These encoders don't report an absolute position but rather generate pulses as the shaft rotates, from which we can deduce movement and direction.

They typically have two output channels, usually called Phase A and Phase B. The signals on these channels are square waves that are 90 degrees out of phase with each other. This phase difference is the key to determining the direction of rotation.

To get a solid grasp of this core concept, please watch the following video.

As the video explained, the direction of rotation is determined by which signal's rising edge leads the other.

The video demonstrated a method using GPIO interrupts on an Arduino. While this works, it can consume significant CPU time, especially at high rotation speeds. The ESP32 provides a much more elegant and efficient solution: the Pulse Counter (PCNT) peripheral, a hardware module designed specifically for tasks like this.

2. The ESP32 Pulse Counter (PCNT) Peripheral

The PCNT peripheral can autonomously count incoming pulses on a GPIO pin. More importantly, it can use the logic level of a second GPIO pin to control how it counts (e.g., incrementing, decrementing, or holding). This makes it perfectly suited for decoding quadrature encoder signals directly in hardware, freeing up the CPU for other tasks like running your control algorithm.

Let's explore the theory and different ways to decode the encoder signals to achieve higher resolution.

Decoding Modes and Resolution

As you just read, we can increase the effective resolution of an encoder by choosing to count more than just the rising edge of one channel.

• 1x Decoding: Counts one edge (e.g., rising) on one channel (e.g., Phase A). You get N counts per revolution, where N is the encoder's native Pulses Per Revolution (PPR).
• 2x Decoding: Counts both the rising and falling edges on one channel. This doubles the resolution to 2N counts per revolution.
• 4x Decoding: Counts every edge on both channels (A rising, B rising, A falling, B falling). This provides the highest resolution of 4N counts per revolution.

Using a single PCNT unit, the most common and efficient method is 2x decoding, which offers a great balance of resolution and implementation simplicity. We will focus on this method.

3. Configuring PCNT for 2x Quadrature Decoding

To implement 2x decoding, we'll connect Phase A of the encoder to the PCNT's edge input and Phase B to its level control input. We then configure the peripheral's behavior with two key function calls:

1. pcnt_channel_set_edge_action(): This tells the PCNT what to do by default on a rising or falling edge of the Phase A signal.
2. pcnt_channel_set_level_action(): This defines how the default action is modified based on the logic level of the Phase B signal.

Let's see exactly how to set this up.

Let's break down the logic for 2x decoding. The configuration is:

• pcnt_channel_set_edge_action(channel, PCNT_CHANNEL_EDGE_ACTION_INCREASE, PCNT_CHANNEL_EDGE_ACTION_DECREASE);

  • Default action on Phase A rising edge: INCREASE
  • Default action on Phase A falling edge: DECREASE

• pcnt_channel_set_level_action(channel, PCNT_CHANNEL_LEVEL_ACTION_INVERSE, PCNT_CHANNEL_LEVEL_ACTION_KEEP);

  • If Phase B is HIGH: INVERSE the default action.
  • If Phase B is LOW: KEEP the default action.

Combining these rules gives us the complete behavior:

• A rises, B is low: INCREASE (kept) -> Count +1
• A falls, B is high: DECREASE (kept) -> Count -1 (Incorrect for CW, see below)
  Let's trace a full clockwise rotation (where A leads B):

1. A rises, B is low: Action is INCREASE, B is low so we KEEP -> Count +1
2. B rises, A is high: (No edge on A, no action)
3. A falls, B is high: Action is DECREASE, B is high so we INVERSE -> Count +1
4. B falls, A is low: (No edge on A, no action)

The article's logic table has a small error in its DECREASE/INCREASE labels but the resulting behavior is correct. Let's trace it correctly:

• A pos edge, B low: Action is INCREASE. B is low, so we KEEP it. Result: Increment. (Correct for CW)
• A pos edge, B high: Action is INCREASE. B is high, so we INVERSE it. Result: Decrement. (Correct for CCW)
• A neg edge, B low: Action is DECREASE. B is low, so we KEEP it. Result: Decrement. (Correct for CCW)
• A neg edge, B high: Action is DECREASE. B is high, so we INVERSE it. Result: Increment. (Correct for CW)

This combination correctly increments the counter twice per cycle for clockwise rotation and decrements it twice for counter-clockwise rotation, achieving 2x decoding.

Finally, the article mentions the glitch filter. This is the hardware solution to the switch "bouncing" problem mentioned in the video. By telling the PCNT to ignore very short pulses (e.g., < 1000 ns), we can get a clean count without any software overhead.

4. Practical Implementation

Now let's translate this theory into a working example. First, here is a typical wiring setup.

Now, let's examine the code that brings this to life.

The code in the article follows a clear, structured approach using the modern ESP-IDF API:

1. Create a PCNT Unit: pcnt_new_unit() is called with a configuration that sets the counter's operational range (high_limit, low_limit).
2. Create a PCNT Channel: pcnt_new_channel() associates the unit with the specific GPIOs for the edge (Phase A) and level (Phase B) inputs.
3. Set Actions: The crucial pcnt_channel_set_edge_action() and pcnt_channel_set_level_action() calls are made to implement the 2x quadrature logic we dissected.
4. Add Glitch Filter: pcnt_unit_set_glitch_filter() is configured to reject noise. A value around 1000 ns is a good starting point for common mechanical encoders.
5. Enable, Clear, and Start: Finally, the unit is enabled, its count is reset to zero, and it is started.

The app_main function then enters a simple loop that periodically calls pcnt_unit_get_count() to retrieve the hardware-maintained count and print it. This value is the raw position feedback from our motor.

Conclusion

In this lesson, you have learned how to transform the physical rotation of a motor shaft into a digital count that your ESP32 can use. This feedback is the missing piece of our motor control system.

Key Takeaways:

• Quadrature encoders use two 90-degree out-of-phase signals (A and B) to provide both position and direction information.
• The ESP32's PCNT peripheral is the ideal tool for this job, decoding encoder signals in hardware efficiently.
• The key to configuration is setting the edge_action (what to do on an edge) and level_action (how to modify that action based on the other signal).
• Using the glitch filter is essential for getting reliable counts from noisy mechanical encoders.
• The final result is a counter, accessible via pcnt_unit_get_count(), that automatically tracks the motor's relative position.

In our next and final lesson of this module, we will put everything together. We will use the position count from the PCNT peripheral to calculate the motor's speed and create a simple closed-loop controller that adjusts the MCPWM duty cycle to maintain a target RPM.