Error "Expecting a Pin" for a Pin derived object

[cve2022]

I am running this class from Thonny

from machine import Pin, PWM

class MyPin(Pin):
    def __init__(self, pin_nbr, *args):
        self.pin_nbr = pin_nbr
        super().__init__(self.pin_nbr, *args)

I am getting the following error when I try to create a PWM object (Pico running micropython 1.19.1):

>>> %Run -c $EDITOR_CONTENT
>>> p0=MyPin(0)
>>> pw=PWM(p0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: expecting a Pin
>>> p0
Pin(0, mode=ALT, alt=4)
>>> type(p0)
<class 'MyPin'>
>>> isinstance(p0, Pin)
True
>>> 

What am I doing wrong?

Thanks in advance for any hint.

[jimmo]

You're not doing anything wrong, it's just that these APIs were not designed to handle this case -- machine.PWM() needs to be given something that is exactly a Pin. Internally it checks the equivalent of type(p) == machine.Pin, not isinstance(p, machine.Pin)`.

It would actually be possible to make this work (although it needs to be fixed in many places across each of the ports), and I'd argue that what you're doing should work. Perhaps raise a feature request?

(FWIW, the way to fix this, on Pico at least, is in mp_hal_get_pin_obj to use mp_obj_cast_to_native_base() rather than mp_obj_is_type.)

[cve2022]

Hello, jimmo.

Thank you very much for the explanation. I am fairly new to python in general and micropython in particular so when these borderline(ish) cases occur, I assume I am doing something wrong and try to understand them as part of my learning process.

Is there a way to pass get the parent class of MyPin to pass it to PWM as a workaround?

FWIW, the reason for MyPin is I need the pin number for a group of MyPWM (that inherits from and extends PWM) objects to synchronize them by directly accessing the rp2040 pwm registers.

Again, thank you very much for your help.

[peterhinch]

Please see #10236 (comment)

[rkompass]

@cve2022: Perhaps you can make use of (part of) this code:

# Improved micropython PWM class for RPi2040
#
# (c) 2022 by rkompass
#
# MIT License
#
# Inspired by and derived from https://github.com/danjperron/PicoAudioPWM/blob/main/myPWM.py
#

# Adds divtop() and duty() methods and div and top arguments to init() and initializer.
# Corrects a bug in deinit().
#
# Note:
# ----
#
# top+1 is the maximum effective duty value. It yields 100% constant output.
# The top argument therefore is limited to 0xfffe = 65534.
# The div argument allows 1/16 fractional values, supplied as floats: e.g. div=1.375.
# The original freq() and duty_u16() methods still work and provide sensible values.
#
# Setting div and/or top parameters changes/determines the PWM frequency.
#
#  freq = machine.freq() / (div * (top+1))
#
# Example:
# --------
#
# from machine import Pin
# from rp2_nupwm import nuPWM
# pwm = nuPWM(Pin(9), div=1.375, top=2060)
# 
# print(pwm.divtop())     # --> (1.375, 2060)
#
# print(pwm.freq())       # --> 44109   , we have constructed a frequency of ~ 44.1 kHz
#                         #               with a dynamic range of ~ 11 bits  (~2048 values)
#
# pwm.duty(1000)          # sets raw duty to 1000
#
# print(pwm.duty_u16())   # --> 31797  , 1000/2061 = 0.4852014, we have a duty of 48.52 %
#                         #     31797 = int(0.4852014 * 65535) is the duty scaled to 16 bits
#
# pwm.freq(44109)         # we set the PWM frequency to ~ 44.1 kHz by the original freq() method
#
# print(pwm.divtop())     # --> (1.625, 1727)   , the original method does not give us a suitable range.
#
# # note that duty_ns() method also works correctly

# Todo:
# -----
#
# Add phase corrected mode.
#
# Add channel-B counter and channel-B-gated timer modes.
#

from machine import PWM, mem16, mem32
from array import array

class nuPWM(PWM):
    def __init__(self, pin, freq=None, div=None, top=None):
        baddr=bytes(array('O', [pin]))
        self.pin = mem32[int.from_bytes(baddr, 'little')+4]
        self.addr = 0x40050000 + 0x14*(self.pin>>1)  # PWM_DIV=addr+4; PWM_TOP=addr+16; PWM_CC=addr+12
        super().__init__(pin)             # This alone does not work. Inheritance of builtin (C-coded) classes
        super().freq(10_000)              #   in uPy is only partially supported.
        super().duty_u16(0)               # With these instructions now inheritance of PWM seems to be o.k..
        if freq is not None or div is not None or top is not None:
            self.init(freq=freq, div=div, top=top)

    def init(self, freq=None, div=None, top=None):   # sets duty to 0 !!!!
        if freq is not None:                         # the freq has prioritiy over divider and top
            super().freq(freq)
        elif div is not None and top is not None:    # only divider and top together lead to alternative PWM setting
            self.divtop(div, top)
        else:
            raise ValueError('supply freq or both div and top arguments to init()')
        self.duty(0)

    def divtop(self, div=None, top=None):
        if div is not None:
            mem32[self.addr+4] =  round(div*16) & 0xfff  # div register holds only div value
        if top is not None:
            if top > 0xfffe:
                raise ValueError('max top value: 65534')
            mem32[self.addr+16] = top & 0xffff           # top register holds only top value
        return mem32[self.addr+4]/16, mem32[self.addr+16]

    def duty(self, value=None):
        if value is not None:
            top = mem32[self.addr+16] & 0xffff
            if value > top+1:
                value = top+1                            # duty == top + 1 -> PWM output 100% on
            if value > 0xffff:
                raise ValueError('max duty value: 65535')
            mem16[self.addr+12+((self.pin&1)<<1)] = value  # duty register holds duties for channels A and B
        return mem16[self.addr+12+((self.pin&1)<<1)]       #  -> we use mem16 to access either one

    def busy(self):
        return (mem32[0x40014004 + 0x08*self.pin] & 0b11111) == 4  # 4 for PWM, 5 for SIO, which is default for pins after reset

    def deinit(self):
        super().deinit()
        ctrl = mem32[0x40014004 + 0x08*self.pin]     # GPIOpin_CTRL    # set back to SIO control, 
        mem32[0x40014004 + 0x08*self.pin] = ctrl & 0xffffff20 | 0x05   #  this was missing in super().deinit()

    def __repr__(self):
        d, t = self.divtop()
        return 'nuPWM(machine.Pin({:d}), div={:.4f}, top={:d}) # freq={:d}'.format(self.pin, d, t, self.freq())

I remember that I was wondering that I needed to set super.freq() and super.duty_u16() in addition to super.__init__() to make things work.
Did you notice this pull request?
Do I recall correctly that there are register commands to advance phases of PWM and the like?

[cve2022]

Hello, rkompass, I will take a look at the code, thank you very much for providing it.

About advancing phases, it would be an option but I think it would be laborious (even if made by software :) ) requiring many iterations until sync is achieved (if ever) and still might not achieve the perfect synchronization I need. I must admit I did not dig deeply into this option though, so I may be wrong.

What I did was stopping the counters right after creating the objects (there is no PWM output at this point as the duty cycle is initialized with 0), zeroing them and then start them again.

I tried two ways, one using mem32...

from micropython import const
from machine import Pin, PWM, mem32

FREQ = const(10000)
DUTY = const(2**15)
PWM_CTR = const((
    0x40050008, 0x4005001c, 0x40050030, 0x40050044,
    0x40050058, 0x4005006c, 0x40050080, 0x40050094
))
GLOBAL_EN = const(0x400500a0)
GLOBAL_EN_SET = const(0x400520a0)
GLOBAL_EN_CLR = const(0x400530a0)
PWM_SET = const(0xFF)

pins = (0, 2, 4, 6, 8, 10, 12, 14)
pwm = [PWM(Pin(i)) for i in pins]
[i.freq(FREQ) for i in pwm]
mem32[GLOBAL_EN_CLR] = PWM_SET
for i in PWM_CTR: mem32[i] = 0
mem32[GLOBAL_EN_SET] = PWM_SET
[i.duty_u16(DUTY) for i in pwm]

... and other using viper:

from micropython import const
from machine import Pin, PWM

FREQ = const(10000)
DUTY = const(2**15)
PWM_CTR = const((
    0x40050008, 0x4005001c, 0x40050030, 0x40050044,
    0x40050058, 0x4005006c, 0x40050080, 0x40050094
))
GLOBAL_EN = const(0x400500a0)
GLOBAL_EN_SET = const(0x400520a0)
GLOBAL_EN_CLR = const(0x400530a0)
PWM_SET = const(0xFF)

pins = (0, 2, 4, 6, 8, 10, 12, 14)
pwm = [PWM(Pin(i)) for i in pins]

@micropython.viper
def init (pwm):
    [i.freq(FREQ) for i in pwm]
    ptr32(GLOBAL_EN_CLR)[0] = PWM_SET
    for i in PWM_CTR: ptr32(i)[0] = 0
    ptr32(GLOBAL_EN_SET)[0] = PWM_SET
    [i.duty_u16(DUTY) for i in pwm]

init(pwm)

The code above is proof-of-concept so it is ugly.

I wrote an article about it (appologies for the shameless plug). It is in Portuguese, but Google may translate it (though it used "logger" where it should use "register" and messed with code formatting).

BR.