Recommended approach to support Adafruit I2C Rotary Push Encoder

[StephenDone]

Hello Peter,

I am working on a project involving a Pico 2 W, a custom Micropython build (to give me more Bluetooth client connections), a Pimoroni Pico Display 2.8 and an AdaFruit I2C rotary encoder module - https://www.adafruit.com/product/4991

What is your recommended method to add support for this encoder?

I've read the other issues relating to rotary encoders. Well, this one is cheap, popular and well documented.

I have attempted an implementation using the VButton class, where I have implemented gui_op_id's 0, 1 and 2 for prev, select and next.
When I call the display constructor, I have passed my device instance in as follows:

display = Display(ssd, *(VButton(dfr) for x in range(5)))

However, when I run your slider_label demo, whilst I can change between gui elements and even exit the app, I am unable to adjust the slider value. I notice that the gui reports that it is 'Using 5 switches', which I guess it would!
But I don't have 5 switches. I have three. I am guessing this is my problem - the gui is expecting widget value adjustments using the increment and decrement buttons (which I don't have).
So I tried constructing the Display as follows:

increase = None
decrease = None
display = Display(ssd, *(VButton(dfr) for x in range(3)), increase, decrease)

...but that just hangs without displaying anything. Is that a bug or 'by design'? Shouldn't I be able to run a mixture of buttons, VButtons and no buttons? My assumption of the problem here is that when using VButton, the system always assumes that you will implement 5 buttons using VButtons, and that less than a 5 buttons implementation is not supported. Furthermore, this approach was not intended to be mixed with physical buttons.

If the above approach is never going to work, I would be happy to write my own primitive for this piece of hardware. But I am somewhat put-off this approach, having seen the pull request where it seems necessary to modify the core code to add what is really a plug-in. Is the pull request OTT to solve the problem? Or is it possible to create a new primitive for my chosen hardware without modifying the core code?

Thanks for any advice.

Stephen Done

[peterhinch]

There is currently no support for I2C encoders. Support is for simple, cheap switch types like this Adafruit one. Switch encoders use a quadrature interface common to optical and magnetic encoders - this is an industry standard interface. By contrast, so far as I know, there is no standard I2C command set.

Properly supporting I2C would require significant additions to the GUI core.

I am wary of adding yet another input option when I2C units seem to offer no particular advantage.

[StephenDone]

That's fair enough. But I was hoping you could point me in the right direction, as to how I might implement it myself.

As you can see, I've tried one method that didn't quite work out though I'm not sure whether that is due to a bug or intended behaviour - perhaps you could confirm. Maybe a small tweak to my code would have things working.

Or I am happy to write an I2C encoder class. But I was hoping you can confirm whether it was necessary to modify the core code or not in order to do this.

I am happy to contribute code to this project if you would like. If my code is up to scratch of course!

I do think that I2C encoder modules have something to offer. For those not too proficient in soldering, they allow connection of the encoder to the micro controller using a simple QT cable. But I'm still not asking you to implement this; only to hopefully nudge me in the right direction!

[peterhinch]

I suggest the following approach. Firstly, port the Adafruit code to MicroPython so that you can issue x = encoder.position and get an "absolute" value - you have probably already done this.

In ugui.py delete line 87

            from gui.primitives import Encoder

Add the following code to ugui.py

class Encoder:
    delay = 100  # Poll delay (ms)

    def __init__(self, pin_x, pin_y, div, callback):  # Pins are dummies
        asyncio.create_task(self._run(div, callback))


    async def _run(self, div, cb):
        av = 0  # Prior hardware value (absolute position)
        pcv = 0  # Prior divided value passed to callback (relative position)
        while True:
            await asyncio.sleep_ms(Encoder.delay)  # Wait for motion/bounce to stop.
            hv = encoder.position  # Sample hardware (assume a driver)
            if hv == av:  # No change
                continue  # Nothing to do.
            dv = hv - pv  # Relative position (sign may be wrong!)
            pv = hv
            cv = round(dv / div)  # cv is divided value (relative).
            if (cv - pcv) != 0:  # dv is change in divided value.
                cb(cv, cv - pcv)  # Run user CB in asyncio context
                pcv = cv

(You will need to import your driver so that hv = encoder.position can work).

This emulates an encoder switch, converting from absolute to relative position.

If Adafruit's code changes position by 1 for each click of the detents a value of 1 for div will suffice - otherwise pass the number by which the position changes. Pass dummy pins for the encoder pins to keep the Display constructor happy - they are ignored. So the constructo "thinks" it's getting a normal encoder.

Obviously this is untested. Good luck!

[StephenDone]

Hi Peter,

Thanks for the pointers and code sample. I didn't think you were going to write the code for me!

I got it working. I ended up doing the following:
Initially I did edit ugui.py. But then I noticed that the code I was replacing was in encoder.py.
So changed things around and left ugui.py alone entirely.
I put my modified Encoder in encoder.py...

from machine import I2C
from seesaw_rotary import ADA5880

class Encoder:
    _instance = None

    def __new__(cls, pin_x, pin_y, div, callback):
        if cls._instance is None:
            print('Creating the Encoder')
            cls._instance = super(Encoder, cls).__new__(cls)

            i2c = I2C(0, freq=100000)
            cls._instance.enc_board = ADA5880(i2c, 0x36)
            asyncio.create_task(cls._instance._run(div, callback))

        return cls._instance

    delay = 100  # Poll delay (ms)

    async def _run(self, div, cb):
        while True:
            await asyncio.sleep_ms(Encoder.delay) # encoder polling interval

            if (ed := self.enc_board.encoder.encoder_delta()) != 0:
                cb(0, ed)  # Run user CB in asyncio context

I then accessed my Encoder instance from pushbutton.py in a sub-class of the Pushbutton class. I renamed the original class to Pushbutton_orig and named my sub-class Pushbutton...

from .encoder import Encoder

class Pushbutton(Pushbutton_orig):
    def __init__(self, pin, suppress=False, sense=None):
        print('Pushbutton.init()')
        self.encoder = Encoder._instance
        assert self.encoder
        super().__init__(pin, suppress, sense)

    def rawstate(self):
        # print(f'rawstate: {self.pin=}')
        value = not self.encoder.enc_board.button.value
        return value

This was certainly baptism by fire into the inner workings of micro gui!
It's lucky that the Pushbutton gets instantiated after the Encoder or my hack wouldn't work like this at all - it's very fragile code.
Possibly the dirtiest code I've written for some time. I needed to have a stern word with myself afterwards... and a shower! After some overnight though, I plan to revisit what I've written and make my hack a bit more robust. I think I need to bring out instantiation of the Encoder to the hardware_setup module, then reference the instance from the encoder and pushbutton modules. This also then exposes the encoder parameters in a more sensible place, alongside the SSD and buttons.

As I was implementing this, I kept thinking about 'Dependency Injection for the Display Class Constructor'. If, instead of a fixed list of button parameters that get appropriated in a variety of ways, you had a list of input device objects, I think it would offer quite a few advantages. You could register multiple buttons or virtual buttons for a single action such as prev or next - voice AND button control for example. Developers could create their own descendants for custom input hardware, just for some button actions etc etc. It might even reduce the code size (or at least not increase it by much) since the increased modularity would mean you could choose not to include some feature code - such as Input vs InputEnc functionality for example. Again, not asking you to do this; more interested in what you think of the idea. I'm wondering if you see any 'gotchas' before I launch into something I later regret!

By the way, thanks for producing such a useful framework that I am sure is helpful to many people, including me.

[peterhinch]

I2C encoder

I have studied the Adafruit code and ordered one of these devices. I prefer a leaner approach to coding device drivers for microcontrollers compared to Adafruit: their seesaw and busio modules are a little portly for my taste. I think I can produce a simple driver and interface code. In any event I'll give it a try and report back, hopefully with a hack, in a few days.

GUI API (Display constructor)

Micro-gui was originally designed for five pushbuttons, accordingly it seemed reasonable to pass initialised Pin instances to the Display constructor. The other input modes were added incrementally in response to suggestions from users and I retained the use of Pin instances for encoders.

With hindsight this was a mistake. A better approach would be to define interface specs for abstract Pushbutton and Encoder devices. In a typical setup.py the code would import primitives.Pushbutton and primitives.Encoder, instantiate these with the pins in use, and pass the objects to the Display constructor. If a user wanted to use (say) and I2C encoder he would import that class in place of primitives.Encoder and pass a suitable instance. This allows the interface to be extended without change to ugui.py.

I have nodded to that approach with virt_button - a non-breaking change. A full implementation would break code, but only hardware_setup.py.

As an example an abstract encoder would be able to accept a callback (provided by ugui after instantiation). Its constructor would take a division ratio plus any hardware args depending on its physical implementation. It would run the callback when a change had taken place, but with a limit to maximum frequency.

Conclusion

It will probably be a while before I proceed with any API changes - I find it helps to think these things through in the abstract before tangling with code. I will experiment with the I2C encoder, though.

[StephenDone]

...and I've just order some basic quadrature encoders to play with too!

Thanks for your comments on the GUI API. I might have a play around. I find that messing with code helps me understand how it all works, even if I hit a dead end or it comes to nothing. I was thinking of something similar, with a base class of say 'InputControl', which can invoke any (or all) of the actions 0-8 of the virt_button. An encoder might implement prev, next and select. A pushbutton on a Pin would probably just invoke a single action, unless someone decided that push and hold does a second action for example. After the Iist of input devices, I would then pass in the Input strategy (corresponding to Input or InputEnc currently). As well as being explicit about the intent of the configuration, it would also allow customisation of the input functionality without alteration of ugui, using perhaps a sub-class of one of the existing ones.

A constructor might then be something like...

display = Display( 
    inputs=[
        PushButton(Pin(10), PREV), # The button needs to know which action it is going to send
        PushButton(Pin(11), NEXT), 
        Adafruit_SeeSaw_I2CEncoder(bus=0, addr=0x36, actions=(INC,DEC,SEL)), # The encoder has a tuple of 3 actions - CW, ACW and Press
        DFR_Speech(bus=1, addr=0x26), # Perhaps the speech recognition maps to every action.
        QuadratureEncoder(x=Pin(1), y=Pin(2), btn=Pin(3), div=4) # Raw encoder with pins and divisor
    ], 
    strategy=InputEnc
)

The above are just thoughts and ideas - a bit of a brain dump!

Hardware setup for Pico Display Pack 2 and 2.8, in case you want to add it to the repo...

Best regards

Steve

# Pico Display Pack 2 / 2.8" 320*240(Pixel) based on ST7789V
# https://shop.pimoroni.com/products/pico-display-pack-2-0
# https://shop.pimoroni.com/products/pico-display-pack-2-8

from machine import Pin, SPI
import gc

from machine import I2C
from seesaw_rotary import ADA5880
from gui.primitives.virt_button import VButton

from drivers.st7789.st7789_4bit import *
SSD = ST7789

gc.collect()  # Precaution before instantiating framebuf

# Conservative low baudrate. Can go to 62.5MHz.
spi = SPI(0, 62_500_000, sck=Pin(18), mosi=Pin(19), miso=None)
pdc = Pin(16, Pin.OUT, value=0)
pcs = Pin(17, Pin.OUT, value=1)
pbl = Pin(20, Pin.OUT, value=1)

# This config is for the display orientated with the A/B/X/Y button labels the right way up.
ssd = SSD(spi, height=240, width=320, dc=pdc, cs=pcs, disp_mode=LANDSCAPE, display=PI_PICO_LCD_2)

# This config is for the display orientated with the Pico's USB port Uppermost
# You'll want to change the button permutation used for nxt/sel/prev from Y/A/B to maybe X/B/Y
# ssd = SSD(spi, height=320, width=240, dc=pdc, cs=pcs, disp_mode=PORTRAIT, display=PI_PICO_LCD_2)

# - - - - - - - - - - - - - - - - - - - - - - - - - -

# Create and export a Display instance
from gui.core.ugui import Display

# https://cdn.shopify.com/s/files/1/0174/1800/files/pico_display_2_schematic.pdf
# https://cdn.shopify.com/s/files/1/0174/1800/files/pico_display_2_8_schematic.pdf
# Button Pinout
BUTTON_A = 12
BUTTON_B = 13
BUTTON_X = 14
BUTTON_Y = 15

# Define control buttons
nxt = Pin(BUTTON_Y, Pin.IN, Pin.PULL_UP)  # Move to next control
sel = Pin(BUTTON_A, Pin.IN, Pin.PULL_UP)  # Operate current control
prev = Pin(BUTTON_B, Pin.IN, Pin.PULL_UP)  # Move to previous control
increase = None ### Pin(BUTTON_X, Pin.IN, Pin.PULL_UP)  # Increase control's value
decrease = None ### Pin(11, Pin.IN, Pin.PULL_UP)  # Decrease control's value

[peterhinch]

You might like to look at my encoders doc. There are some interesting subtleties around quadrature encoders, also a lot of inaccurate information and needlessly complex code.

I wrote the doc in an attempt to close down some heated debates and to provide a proof that the exclusive or algorithm is correct.

[StephenDone]

Here's my Adafruit Rotary Encoder lash-up. All in a single file with some test code in main(). It can access the rotation steps, button and Neopixel LED. Also sets up the interrupt output, if you'd prefer not to poll. Plenty of unused methods that could be chopped out. Portly is generous. Definitely bloated. Bordering on the morbidly obese. Also worth keeping the Neopixel brightness down, unless you fancy trying a spot of DIY Lasik.

import time
import struct
from machine import I2C

_STATUS_BASE = const(0x00)
_GPIO_BASE   = const(0x01)
_TOUCH_BASE  = const(0x0F)

_GPIO_DIRSET_BULK = const(0x02)
_GPIO_DIRCLR_BULK = const(0x03)
_GPIO_BULK        = const(0x04)
_GPIO_BULK_SET    = const(0x05)
_GPIO_BULK_CLR    = const(0x06)
_GPIO_BULK_TOGGLE = const(0x07)
_GPIO_INTENSET    = const(0x08)
_GPIO_INTENCLR    = const(0x09)
_GPIO_INTFLAG     = const(0x0A)
_GPIO_PULLENSET   = const(0x0B)
_GPIO_PULLENCLR   = const(0x0C)

_STATUS_HW_ID     = const(0x01)
_STATUS_VERSION   = const(0x02)
_STATUS_OPTIONS   = const(0x03)
_STATUS_TEMP      = const(0x04)
_STATUS_SWRST     = const(0x7F)

_HW_ID_CODE       = const(0x55)

class Seesaw:
    """Driver for SeeSaw I2C generic conversion trip.
       :param I2C i2c: I2C bus the SeeSaw is connected to.
       :param int addr: I2C address of the SeeSaw device."""
    
    INPUT          = const(0x00)
    OUTPUT         = const(0x01)
    INPUT_PULLUP   = const(0x02)
    INPUT_PULLDOWN = const(0x03)

    def __init__(self, i2c, addr):
        self.i2c = i2c
        self.addr = addr
        self.sw_reset()

    def sw_reset(self):
        """Trigger a software reset of the SeeSaw chip"""
        self._write8(_STATUS_BASE, _STATUS_SWRST, 0xFF)
        time.sleep(.500)

        chip_id = self._read8(_STATUS_BASE, _STATUS_HW_ID)

        if chip_id != _HW_ID_CODE:
            raise RuntimeError("SeeSaw hardware ID returned (0x{:x}) is not "
                               "correct! Expected 0x{:x}. Please check your wiring."
                               .format(chip_id, _HW_ID_CODE))

    def _write8(self, reg_base, reg, value):
        self._write(reg_base, reg, bytearray([value]))

    def _read8(self, reg_base, reg):
        ret = bytearray(1)
        self._read(reg_base, reg, ret)
        return ret[0]

    def _read(self, reg_base, reg, buf, delay=.005):
        self._write(reg_base, reg)

        time.sleep(delay)

        self.i2c.readfrom_into(self.addr, buf)

    def _write(self, reg_base, reg, buf=None):
        full_buffer = bytearray([reg_base, reg])
        if buf is not None:
            full_buffer += buf

        self.i2c.writeto(self.addr, full_buffer)

    def get_version(self):
        """Retrieve the 'version' word from the SeeSaw board"""
        buf = bytearray(4)
        self._read(_STATUS_BASE, _STATUS_VERSION, buf)
        ret = struct.unpack(">I", buf)[0]
        return ret
#region Pin Mode    
    def pin_mode(self, pin, mode):
        """Set the mode of a pin by number"""
        if pin >= 32:
            self.pin_mode_bulk_b(1 << (pin - 32), mode)
        else:
            self.pin_mode_bulk(1 << pin, mode)

    def _pin_mode_bulk_x(self, capacity, offset, pins, mode):
        cmd = bytearray(capacity)
        cmd[offset:] = struct.pack(">I", pins)
        if mode == self.OUTPUT:
            self._write(_GPIO_BASE, _GPIO_DIRSET_BULK, cmd)
        elif mode == self.INPUT:
            self._write(_GPIO_BASE, _GPIO_DIRCLR_BULK, cmd)
            self._write(_GPIO_BASE, _GPIO_PULLENCLR, cmd)

        elif mode == self.INPUT_PULLUP:
            self._write(_GPIO_BASE, _GPIO_DIRCLR_BULK, cmd)
            self._write(_GPIO_BASE, _GPIO_PULLENSET, cmd)
            self._write(_GPIO_BASE, _GPIO_BULK_SET, cmd)

        elif mode == self.INPUT_PULLDOWN:
            self._write(_GPIO_BASE, _GPIO_DIRCLR_BULK, cmd)
            self._write(_GPIO_BASE, _GPIO_PULLENSET, cmd)
            self._write(_GPIO_BASE, _GPIO_BULK_CLR, cmd)

        else:
            raise ValueError("Invalid pin mode")

    def pin_mode_bulk(self, pins, mode):
        """Set the mode of all the pins on the 'A' port as a bitmask"""
        self._pin_mode_bulk_x(4, 0, pins, mode)

    def pin_mode_bulk_b(self, pins, mode):
        """Set the mode of all the pins on the 'B' port as a bitmask"""
        self._pin_mode_bulk_x(8, 4, pins, mode)
#endregion
#region Digital Read/Write
    def digital_write(self, pin, value):
        """Set the value of an output pin by number"""
        if pin >= 32:
            self.digital_write_bulk_b(1 << (pin - 32), value)
        else:
            self.digital_write_bulk(1 << pin, value)

    def digital_write_bulk(self, pins, value):
        """Set the mode of pins on the 'A' port as a bitmask"""
        cmd = struct.pack(">I", pins)
        if value:
            self._write(_GPIO_BASE, _GPIO_BULK_SET, cmd)
        else:
            self._write(_GPIO_BASE, _GPIO_BULK_CLR, cmd)

    def digital_write_bulk_b(self, pins, value):
        """Set the mode of pins on the 'B' port as a bitmask"""
        cmd = bytearray(8)
        cmd[4:] = struct.pack(">I", pins)
        if value:
            self._write(_GPIO_BASE, _GPIO_BULK_SET, cmd)
        else:
            self._write(_GPIO_BASE, _GPIO_BULK_CLR, cmd)

    def digital_read(self, pin):
        """Get the value of an input pin by number"""
        if pin >= 32:
            return self.digital_read_bulk_b(1 << (pin - 32)) != 0
        return self.digital_read_bulk(1 << pin) != 0

    def digital_read_bulk(self, pins, delay=0.008):
        """Get the values of all the pins on the 'A' port as a bitmask"""
        buf = bytearray(4)
        self._read(_GPIO_BASE, _GPIO_BULK, buf, delay=delay)
        try:
            ret = struct.unpack(">I", buf)[0]
        except OverflowError:
            buf[0] = buf[0] & 0x3F
            ret = struct.unpack(">I", buf)[0]
        return ret & pins

    def digital_read_bulk_b(self, pins, delay=0.008):
        """Get the values of all the pins on the 'B' port as a bitmask"""
        buf = bytearray(8)
        self._read(_GPIO_BASE, _GPIO_BULK, buf, delay=delay)
        ret = struct.unpack(">I", buf[4:])[0]
        return ret & pins
#endregion
#region GPIO    
    def set_GPIO_interrupts(self, pins, enabled):
        """Enable or disable the GPIO interrupt"""
        cmd = struct.pack(">I", pins)
        if enabled:
            self._write(_GPIO_BASE, _GPIO_INTENSET, cmd)
        else:
            self._write(_GPIO_BASE, _GPIO_INTENCLR, cmd)

    def get_GPIO_interrupt_flag(self, delay=0.008):
        """Read and clear GPIO interrupts that have fired"""
        buf = bytearray(4)
        self._read(_GPIO_BASE, _GPIO_INTFLAG, buf, delay=delay)
        return struct.unpack(">I", buf)[0]
#endregion

class digitalio:
    class DriveMode:
        """Drive Mode Enumeration"""
        PUSH_PULL = 0
        OPEN_DRAIN = 1

    class Direction:
        """Direction Enumeration"""
        DIR_INPUT = 0 
        DIR_OUTPUT = 1

    class Pull:
        """PullUp/PullDown Enumeration"""
        UP = 0
        DOWN = 1

class DigitalIO:
    """CircuitPython-compatible class for digital I/O pins

    This class is intended to be a compatible subset of `digitalio.DigitalInOut`.

    Due to technical limitations, PULL_DOWNs are not supported.

    :param ~adafruit_seesaw.seesaw.Seesaw seesaw: The device
    :param int pin: The pin number on the device"""

    def __init__(self, seesaw:Seesaw, pin):
        self._seesaw = seesaw
        self._pin = pin
        self._drive_mode = digitalio.DriveMode.PUSH_PULL
        self._direction = digitalio.Direction.DIR_INPUT
        self._pull = None
        self._value = False

    def deinit(self):
        pass

    def switch_to_output(self, value=False, drive_mode=digitalio.DriveMode.PUSH_PULL):
        """Switch the pin to output mode"""
        self._seesaw.pin_mode(self._pin, self._seesaw.OUTPUT)
        self._seesaw.digital_write(self._pin, value)
        self._drive_mode = drive_mode
        self._pull = None

    def switch_to_input(self, pull=None):
        """Switch the pin to input mode"""
        if pull == digitalio.Pull.DOWN:
            self._seesaw.pin_mode(self._pin, self._seesaw.INPUT_PULLDOWN)
        elif pull == digitalio.Pull.UP:
            self._seesaw.pin_mode(self._pin, self._seesaw.INPUT_PULLUP)
        else:
            self._seesaw.pin_mode(self._pin, self._seesaw.INPUT)
        self._pull = pull

    def set_interrupt(self, enabled):
        self._seesaw.set_GPIO_interrupts(1 << self._pin, enabled)

    def enable_interrupt(self):
        self.set_interrupt(True)

    @property
    def direction(self):
        """Retrieve or set the direction of the pin"""
        return self._direction

    @direction.setter
    def direction(self, value):
        if value == digitalio.Direction.DIR_OUTPUT:
            self.switch_to_output()
        elif value == digitalio.Direction.DIR_INPUT:
            self.switch_to_input()
        else:
            raise ValueError("Out of range")
        self._direction = value

    @property
    def value(self):
        """Retrieve or set the value of the pin"""
        if self._direction == digitalio.Direction.DIR_OUTPUT:
            return self._value
        return self._seesaw.digital_read(self._pin)

    @value.setter
    def value(self, val):
        if not 0 <= val <= 1:
            raise ValueError("Out of range")
        self._seesaw.digital_write(self._pin, val)
        self._value = val

    @property
    def drive_mode(self):
        """Retrieve or set the drive mode of an output pin"""
        return self._drive_mode

    @drive_mode.setter
    def drive_mode(self, mode):
        pass

    @property
    def pull(self):
        """Retrieve or set the pull mode of an input pin"""
        return self._pull

    @pull.setter
    def pull(self, mode):
        if self._direction == digitalio.Direction.DIR_OUTPUT:
            raise AttributeError("cannot set pull on an output pin")
        if mode == digitalio.Pull.DOWN:
            self._seesaw.pin_mode(self._pin, self._seesaw.INPUT_PULLDOWN)
        elif mode == digitalio.Pull.UP:
            self._seesaw.pin_mode(self._pin, self._seesaw.INPUT_PULLUP)
        elif mode is None:
            self._seesaw.pin_mode(self._pin, self._seesaw.INPUT)
        else:
            raise ValueError("Out of range")

_NEOPIXEL_BASE           = const(0x0E)
_NEOPIXEL_SET_PIN        = const(0x01)
_NEOPIXEL_SET_SPEED      = const(0x02)
_NEOPIXEL_SET_BUF_LENGTH = const(0x03)
_NEOPIXEL_BUF            = const(0x04)
_NEOPIXEL_SHOW           = const(0x05)

class NeoPixel():
    def __init__(self, seesaw:Seesaw):
        self.seesaw = seesaw

    def pin_mode_neopixel(self, pin):
        self.seesaw._write(_NEOPIXEL_BASE, _NEOPIXEL_SET_PIN, [pin])

    def set_neopixel_speed(self, speed):
        self.seesaw._write(_NEOPIXEL_BASE, _NEOPIXEL_SET_SPEED, [speed])

    def set_neopixel_buf_length(self, length):
        # Length is in bytes (3 per pixel for RGB)
        self.seesaw._write(_NEOPIXEL_BASE, _NEOPIXEL_SET_BUF_LENGTH, [length >> 8, length & 0xFF])

    def set_pixel_color(self, n, r, g, b):
        offset = n * 3
        # Address + Offset High + Offset Low + Data (R, G, B)
        self.seesaw._write(_NEOPIXEL_BASE, _NEOPIXEL_BUF, [offset >> 8, offset & 0xFF, g, r, b])

    def show(self):
        self.seesaw._write(_NEOPIXEL_BASE, _NEOPIXEL_SHOW, [])

class RotaryEncoder():
    _ENCODER_BASE     = 0x11
    _ENCODER_STATUS   = 0x00
    _ENCODER_INTENSET = 0x10
    _ENCODER_INTENCLR = 0x20
    _ENCODER_POSITION = 0x30
    _ENCODER_DELTA    = 0x40

    def __init__(self, seesaw:Seesaw):
        self.seesaw = seesaw

    def encoder_position(self, encoder=0):
        """The current position of the encoder"""
        buf = bytearray(4)
        self.seesaw._read(self._ENCODER_BASE, self._ENCODER_POSITION + encoder, buf)
        return struct.unpack(">i", buf)[0]

    def set_encoder_position(self, pos, encoder=0):
        """Set the current position of the encoder"""
        cmd = struct.pack(">i", pos)
        self.seesaw._write(self._ENCODER_BASE, self._ENCODER_POSITION + encoder, cmd)

    def encoder_delta(self, encoder=0):
        """The change in encoder position since it was last read"""
        buf = bytearray(4)
        self.seesaw._read(self._ENCODER_BASE, self._ENCODER_DELTA + encoder, buf)
        return struct.unpack(">i", buf)[0]

    def enable_encoder_interrupt(self, encoder=0):
        """Enable the interrupt to fire when the encoder changes position"""
        self.seesaw._write8(self._ENCODER_BASE, self._ENCODER_INTENSET + encoder, 0x01)

    def disable_encoder_interrupt(self, encoder=0):
        """Disable the interrupt from firing when the encoder changes"""
        self.seesaw._write8(self._ENCODER_BASE, self._ENCODER_INTENCLR + encoder, 0x01)    

class ADA5880:
    def __init__(self, i2c, addr=0x36):
        self.seesaw = Seesaw(i2c, addr)
        self.seesaw_version = self.seesaw.get_version()

        # Setup encoder pushbutton
        BUTTON_PIN = 24
        self.button = DigitalIO(self.seesaw, BUTTON_PIN)
        self.button.switch_to_input(digitalio.Pull.UP)
        self.button.set_interrupt(True)

        # Setup rotary encoder
        self.encoder = RotaryEncoder(self.seesaw)
        self.encoder.enable_encoder_interrupt()

        PIXEL_PIN = 6     # The pin ON THE SEESAW CHIP, not your MCU
        NUM_PIXELS = 1    # Number of LEDs in your strip
        self.neopixel = NeoPixel(self.seesaw)
        self.neopixel.pin_mode_neopixel(PIXEL_PIN)
        self.neopixel.set_neopixel_buf_length(NUM_PIXELS * 3)

    def set_neopixel(self, r:int,g:int,b:int):
        self.neopixel.set_pixel_color(0, r, g, b)
        self.neopixel.show()

    def firmware_version(self) -> int:
        return self.seesaw_version >> 16
    
    def __str__(self) -> str:
        return f'Seesaw with firmware {self.firmware_version()} at address 0x{self.seesaw.addr:02X} on {self.seesaw.i2c}'

if __name__ == "__main__":

    print("Running rotary.py test code...")

    i2c = I2C(0, freq=100000)       # create I2C peripheral at frequency of 100kHz
                                    # depending on the port, extra parameters may be required
                                    # to select the peripheral and/or pins to use

    slaves = i2c.scan()
    print(f'Found i2c slaves:', ' '.join(f'0x{x:02X}' for x in slaves))

    enc_board = ADA5880(i2c, 0x36)

    print(enc_board)

    button_held = False
    pos=0
    
    enc_board.set_neopixel(r=1,g=1,b=1)

    while True:
        newpos = enc_board.encoder.encoder_position()
        if(pos != newpos):
            pos=newpos
            print(pos)

            level = 1
            r = level *  pos    % 3
            g = level * (pos+1) % 3
            b = level * (pos+2) % 3
            enc_board.set_neopixel(r,g,b)

        if not enc_board.button.value and not button_held:
            button_held = True
            print('Button Pressed')

        if enc_board.button.value and button_held:
            button_held = False
            print('Button Released')

        time.sleep_ms(50)

[peterhinch]

[EDIT] I had hoped to produce something smaller - however now I've had the chance to experiment, the seesaw chip on the board that converts encoder signals to I2C does seem rather unwieldy. Even reading the state of a GPIO pin requires a surprising amount of code. I'm starting to doubt whether there is much scope for pruning.

As a rough comparison, Adafruit's seesaw.py that runs on the target comprises 430LOC - compare with my encoder.py at 55LOC. I do feel it's an overcomplicated solution. While I'll investigate some more, I have doubts about supporting this device.

[peterhinch]

I have produced the following demo, intended to be fairly minimal:

import time
import struct
from machine import SoftI2C, Pin

_addr = const(0x36)
i2c = SoftI2C(Pin(16), Pin(17), freq=100_000)

def send(data, ms=10):
    i2c.writeto(_addr, data)
    time.sleep_ms(ms)

send(b"\x00\x7f\xff", 500)
send(b"\x00\x01", 20)
i2c.readfrom(_addr, 1)
send(b"\x01\x03\x01\x00\x00\x00")
send(b"\x01\x0B\x01\x00\x00\x00")
send(b"\x01\x05\x01\x00\x00\x00")
send(b"\x01\x08\x01\x00\x00\x00", 300)

buf = bytearray(4)
pos = 0
press = False
while True:
    send(b"\x11\x30", 100)  # Encoder position
    # send(b"\x11\x40", 100)  # Encoder delta
    i2c.readfrom_into(_addr, buf)
    p = struct.unpack(">i", buf)[0]
    if p != pos:
        pos = p
        print(p)
    send(b"\x01\x04")  # Pushbutton
    i2c.readfrom_into(_addr, buf)
    pressed = not buf[0] & 1
    if press ^ pressed:
        print(f"Button {'' if pressed else 'not'} pressed")
        press = pressed

Please note that this is a hack.

I adapted your code to remove the neopixel calls and ran it with a logic analyser on the I2C bus. The above replicates the bus transfers which occurred. The interface is evidently timing-critical: try to initiate a transfer too soon after its predecessor and the seesaw chip crashes. The lack of a proper handshake strikes me as concerning. I haven't managed to locate an interface specification for the seesaw, so there is code here which I cannot justify!

The bottom line is that I do not intend to support this device.

[StephenDone]

Fair enough.
The code is certainly shorter though!