When using multiple rotary encoders (hw) at the same board, all events will fire for all rotary encoders

[M463]

Repro steps

1. Connect multiple rotary encoders to a single Raspberry Pi Pico board, using dedicated GPIO pins for each encoder.
2. Set up RotaryEncoderRP2 objects for the correct pins for each connected rotary encoder.
3. Subscribe to different events via RotaryEncoderRP2.on() for each connected rotary encoder.
4. Run the program on the Raspberry Pi Pico.

Actual result

When operating one rotary encoder, all events of the same type will trigger for all connected rotary encoders.
E.g. when using three encoders and turning encoder 1 to the left, the .TURN_LEFT event type will be triggered for encoder 2 and 3 as well.

Expected result

Operating a single rotary encoder shall only call it's own listeners when it triggers an event.

[M463]

Proposed fix now subject to PR #2.

[CannonFodderSE]

Greetings,
Do you have a sample of code for multiple encoders?

Thanks,
Randy

[CannonFodderSE]

M463,
I applied your patch and got it working.

Thanks!
Randy

[M463]

Sorry for the late reply. You don't have to do anything special, the fix is in the library itself.
Just declare your rotary encoder objects and they will work independently and not interfere with each other.
Below is some sample code of an elevation/rotation controller with two rotary encoders, just in case somebody else comes across this thread in the future. 🙂

class EncoderHandler:
    def __init__(self):
        self.min = 0
        self.max = 180
        # Servo() class not part of this example code
        self.servo = Servo(servo_pin_number, min_deg=self.min, max_deg=self.max)
        self.set_counter(self.max // 2)

    def set_counter(self, target_value):
        self.count = target_value
        # Servo() class not part of this example code
        self.servo.move_to_angle(self.count)

    def increase(self, step_width=1):
        target_count = self.count + step_width
        if target_count >= self.max:
            # move to min value if max value is reached/exceeded
            self.set_counter(self.min)
        else:
            self.set_counter(target_count)

    def decrease(self, step_width=1):
        target_count = self.count - step_width
        if target_count <= self.min:
            # move to max value if min value is reached/exceeded
            self.set_counter(self.max)
        else:
            self.set_counter(target_count)

    def increase_wide(self):
        self.increase(25)

    def decrease_wide(self):
        self.decrease(25)

# create pins for encoders and buttons
en_l_pin_clk = Pin(13, Pin.IN, Pin.PULL_UP)
en_l_pin_dt = Pin(12, Pin.IN, Pin.PULL_UP)
en_l_pin_sw = Pin(11, Pin.IN, Pin.PULL_UP)

en_r_pin_clk = Pin(18, Pin.IN, Pin.PULL_UP)
en_r_pin_dt = Pin(19, Pin.IN, Pin.PULL_UP)
en_r_pin_sw = Pin(20, Pin.IN, Pin.PULL_UP)

# create encoder objects
encoder_elevation = RotaryEncoderRP2(en_r_pin_clk, en_r_pin_dt, en_r_pin_sw)
encoder_rotation = RotaryEncoderRP2(en_l_pin_clk, en_l_pin_dt, en_l_pin_sw)

# subscribe to encoder events
elevation_handler = EncoderHandler(22)
encoder_elevation.on(RotaryEncoderEvent.CLICK, elevation_handler.wiggle_servo)
encoder_elevation.on(RotaryEncoderEvent.TURN_RIGHT, elevation_handler.increase)
encoder_elevation.on(RotaryEncoderEvent.TURN_LEFT, elevation_handler.decrease)
encoder_elevation.on(RotaryEncoderEvent.TURN_RIGHT_FAST, elevation_handler.increase_wide)
encoder_elevation.on(RotaryEncoderEvent.TURN_LEFT_FAST, elevation_handler.decrease_wide)

rotation_handler = EncoderHandler(26)
encoder_rotation.on(RotaryEncoderEvent.CLICK, rotation_handler.wiggle_servo)
encoder_rotation.on(RotaryEncoderEvent.TURN_RIGHT, rotation_handler.increase)
encoder_rotation.on(RotaryEncoderEvent.TURN_LEFT, rotation_handler.decrease)
encoder_rotation.on(RotaryEncoderEvent.TURN_RIGHT_FAST, rotation_handler.increase_wide)
encoder_rotation.on(RotaryEncoderEvent.TURN_LEFT_FAST, rotation_handler.decrease_wide)