HBridgeIC - H-bridge integrated circuit.

[IhorNehrutsa]

TB6612, L298, L293, L9110, DRV8871, DRV8837, DRV8838, BTS7960 etc.

Let's design HBridgeXXX classes here.

HBridge(discrete components) - motor control #12083
PWM: Reduce inconsistencies between ports. #10817
PWM: Reduce inconsistencies between ports 2. #12084

[2dof]

Let's design H_bridge here.

Do You mean a driver for H_Bridge?

[sosi-deadeye]

I used in the past this module: https://www.sparkfun.com/products/14451 (TB6612FNG)
There is also this breakout board with L298N: https://bc-robotics.com/shop/l298n-motor-driver-board/ (5V !!)

TB6612FNG has a different logic as L298N.
The short-breake requires both direction pins to be high.

Here something to start (not tested with hardware):

import math
from machine import Pin, PWM

U16 = 65535

class HBridge:
    """
    For TB66FNG12
    Datasheet: https://www.sparkfun.com/datasheets/Robotics/TB6612FNG.pdf
    Page: 4

    The modes of the bridge are:
    - Short brake
    - Turn Clockwise
    - Turn Counter clockwise
    - Stop (no breake, high impendance)
    - Standby (high impendance)
    """
    def __init__(self, pwm: PWM, ain1: Pin, ain2: Pin, standby: Pin, invert=False):
        self._pwm = pwm
        self._ain1 = ain1
        self._ain2 = ain2
        self._standby = standby
        if invert:
            # swapping methods
            self.left, self.right = self.right, self.left
            
        self._setup()

    def _setup(self):
        self._pwm.init(freq=1_000, duty_u16=0)
        self._ain1.init(mode=Pin.OUT, value=0)
        self._ain2.init(mode=Pin.OUT, value=0)
        self._standby.init(mode=Pin.OUT, value=0)
    
    @staticmethod
    def to_u16(value) -> int:
        return min(max(math.floor(value / 100 * U16), 0), U16)
        
    def stop_breake(self):
        """
        Short breake
        """
        self._pwm.duty_u16(0)
        self._ain1.value(1)
        self._ain2.value(1)
        self._standby.value(1)
    
    def stop(self):
        """
        Stop (high impendance)
        """
        self._pwm.duty_u16(U16)
        self._ain1.value(0)
        self._ain2.value(0)
        self._standby.value(1)
    
    def standby(self):
        """
        Standby, same like stop
        """
        self._pwm.duty_u16(0)
        self._ain1.value(0)
        self._ain2.value(0)
        self._standby.value(0)

    def left(self, speed: float | int = 100):
        """
        Turn motor left with a speed (0 - 100%) 
        """
        self._ain1.value(1)
        self._ain2.value(0)
        self._standby.value(1)
        self._pwm.duty_u16(self.to_u16(speed))

    def right(self, speed: float | int = 100):
        """
        Turn motor right with a speed (0 - 100%) 
        """
        self._ain1.value(0)
        self._ain2.value(1)
        self._standby.value(1)
        self._pwm.duty_u16(self.to_u16(speed))


motor1 = HBridge(PWM(Pin(10)), Pin(20), Pin(21), Pin(22))
motor2 = HBridge(PWM(Pin(12)), Pin(25), Pin(26), Pin(27), invert=True)

[rkompass]

Current incarnation of the code is:

#  Micropython Drivers for H-Bridge Motor Drivers TB66FNG12 and L298 and DRV8871
#
#  Datasheets: https://www.sparkfun.com/datasheets/Robotics/TB6612FNG.pdf  and
#              https://www.bc-robotics.com/datasheets/l298n.pdf
#              https://www.ti.com/lit/ds/symlink/drv8871.pdf
#
#  These drivers work in sign-magnitude mode.
#  When using PWM for Forward and Reverse mode they switch between driving and braking.
#  This is intended and also called slow synchronous current decay.
#  For an explanation see: TI Application Report "Current Recirculation and Decay Modes"
#                                     https://www.ti.com/lit/an/slva321a/slva321a.pdf
#  The modes of the bridges are:
#     - Forward (turn clockwise)
#     - Backward (turn counter-clockwise)
#     - Brake (fast motor stop, both motor outputs connected)
#     - Stop (Coast, slow motor stop, no brake, high impendance)
#
#  This code developed from a discussion on https://github.com/micropython/micropython/discussions/10983
#  Contributors: IhorNehrutsa, sosi-deadeye, rkompass


from machine import Pin, PWM


#  ----   Circuitry and Setup for TB6612  -----
#
#  in2 | in1 | pwm | stby
# -----------------------
#   X  |  X  |  X  |  L    Stop   (free running motor stop, i.e. high impedance)
# -----------------------
#   L  |  L  |  L  |  H    ????   (missing in datasheet)
#   L  |  L  |  H  |  H    Stop   (high impedance)
# -----------------------
#   L  |  H  |  L  |  H    Brake  (fast motor stop)
#   L  |  H  |  H  |  H    Forward
#   H  |  L  |  L  |  H    Brake  (fast motor stop)
#   H  |  L  |  H  |  H    Reverse
# -----------------------
#   H  |  H  |  X  |  H    Brake  (fast motor stop)
#
# The TB6612 has 3 inputs for each motor: Ain1, Ain2, pwmA for Motor A and Bin1, Bin2, pwmB for Motor B.
# Connect these 3 inputs to 3 pins of the Microcontroller.
# Create Pin objects for the two input pins like:  ain1, ain2 = machine.Pin(2), machine.Pin(3)
#    and a pin object for the pwm pin like:        pwma = machine.Pin(4)
# The TB6612 has a standby input for both motors that you don't need: connect it to Vcc (input side).
# Setting this pin low would set both motors to high impedance (Stop) mode, which you may achieve with this drivers Stop mode.

class HBridge6612:

    # The class initializer receives the direction pins as a 2-tuple or 2-list:
    #     motor = HBridge6612((ain1, ain2), pwma)                         # or
    #     motor = HBridge6612(reversed((ain1, ain2)), pwma, freq = 1000)  # for exchange of Clockwise and CounterClw
    #                                                                     #    and explicit setting of PWM frequency
    def __init__(self, in12, pwm, freq=1000):
        in12 = tuple(in12)   # make a tuple again in case we got a generator from reversed()
        self.in1 = in12[0]
        self.in2 = in12[1]
        self.pwm = PWM(pwm, freq=freq, duty_u16=0) # should start the pwm !!!?
        for pin in (in12):
            pin.init(mode=Pin.OUT, value=0)
        #  --  Constants for Modes of the HBridge6612.go() function:  --
        self.Stop = None     #  Both outputs not connected (high impedance)
        self.Brake = 0       #  Brake: out1 = out2 = PGND  (both outputs conn. to GND)

    # motor.go(80)          # Forward, 80% speed
    # motor.go(0)           # Brake,  (both motor outputs connected to GND)
    # motor.go(motor.Brake) #        --     ||     --
    # motor.go(-100)        # Backward, full speed
    # motor.go(None)        # Stop, (both motor outputs high impedance)
    # motor.go(motor.Stop)  #        --     ||     --
    #
    def go(self, speed):
        if speed > 0:
            self.in1(1); self.in2(0)
        elif speed < 0:
            self.in1(0); self.in2(1)
            speed = -speed
        elif speed == 0:               # speed == 0     --> Brake
            self.in1(1); self.in2(1)
        else:                          # speed == None  --> Stop
            self.in1(0); self.in2(0)
            speed = 0
        self.pwm.duty_u16(min(int(speed*655.35), 65535))


#  ----   Circuitry and Setup for L298  -----
#
#  in2 | in1 | enA
# -----------------
#   X  |  X  |  L    Stop   (free running motor stop, i.e. high impedance)
# -----------------
#   L  |  L  |  H    Brake  (fast motor stop)
#   L  |  H  |  H    Forward
#   H  |  L  |  H    Reverse
#   H  |  H  |  H    Brake  (fast motor stop)
# 
# The L298 has 3 inputs for each motor: in1, in2, enA for Motor A and in3, in4, enB for Motor B, of which
#   the two inputs in1, in2 (or in3, in4) are sufficient to control the motor.
# Connect these inputs to two pins of the Microcontroller.
# The enable pin enA (or enB) may be set with a jumper to H (high) or connected to a third pin of the microcontroller
#   if you want to be able to set the Stop mode (free running motor stop, i.e. high impedance) from the driver.
# Create Pin objects for the two input pins like:  in1, in2 = machine.Pin(2), machine.Pin(3)
# Optionally create an enable Pin object like: enA = machine.Pin(4) if you want to use Stop mode.

# Should also work with L293 (see Figure10, Table 3 of Datasheet)
# Should also work with L9110 (no enable pin)

class HBridge298:

    # The class initializer receives the direction pins as a 2-tuple or 2-list:
    # motor = HBridge298((in1, in2))                                 #  or
    # motor = HBridge298(reversed((in1, in2)), en=enA, freq = 2000)  #  for exchange of Clockwise and CounterClw
    #                                                                #  and Stop mode and user defined PWM frequency
    def __init__(self, in12, en=None, freq=1000):
        in12 = tuple(in12)   # make a tuple again in case we got a generator from reversed()
        self.pwm1 = PWM(in12[0], freq=freq, duty_u16=0)
        self.pwm2 = PWM(in12[1], freq=freq, duty_u16=0)
        self.en = en
        if en is not None:  
            self.en.init(mode=Pin.OUT, value=1)
        # --  Constants for Modes of the HBridge298.go() function:  --
        self.Stop = None   #  Both outputs not connected (high impedance)
        self.Brake = 0     #  Brake: out1 = out2 = PGND  (both outputs conn. to GND)

    # motor.go(80)          # Forward, 80% speed
    # motor.go(0)           # Brake,  (both motor outputs connected to GND)
    #   or motor.go(motor.Brake)
    # motor.go(-100)        # Backward, full speed
    # motor.go(None)        # Stop, (both motor outputs high impedance)
    #   or motor.go(motor.Stop)
    #
    def go(self, speed):
        self.pwm1.duty_u16(min(int(speed*655.35), 65535) if speed > 0 else 0)  # we somewhat rely on the pin being low at
        self.pwm2.duty_u16(min(int(-speed*655.35), 65535) if speed < 0 else 0) # duty_u16(0)
        if self.en is not None:
            self.en(1 if speed is not None else 0)


#  ----   Circuitry and Setup for DRV8871  -----
#
#   in2 | in1 
#  -----------
#    X  |  X     
#  -----------
#    L  |  L     Stop / Coast (free running motor stop, i.e. high impedance)
#    L  |  H     Forward
#    H  |  L     Reverse
#    H  |  H     Brake  (fast motor stop)
#
#  This is called IN-IN interface in the Datasheet
# 
# The DRV8871 has 2 inputs for the motor: in1, in2
# Connect these inputs to two pins of the Microcontroller.
# Create Pin objects for the two input pins like:  in1, in2 = machine.Pin(2), machine.Pin(3)



# ???? this driver relies on PWM signal high at pwm.duty_u16(65535)
# should we use an inverse option of pwm ????
# 
class HBridge8871:

    # The class initializer receives the direction pins as a 2-tuple or 2-list:
    # motor = HBridge8871((in1, in2))                            #  or
    # motor = HBridge8871(reversed((in1, in2)), freq = 2000)     #  for exchange of Clockwise and CounterClw
    #                                                            #  and user defined PWM frequency
    def __init__(self, in12, freq=1000):
        in12 = tuple(in12)   # make a tuple again in case we got a generator from reversed()
        self.pwm1 = PWM(in12[0], freq=freq, duty_u16=65535)
        self.pwm2 = PWM(in12[1], freq=freq, duty_u16=65535)
        # --  Constants for Modes of the HBridge298.go() function:  --
        self.Stop = None   #  Both outputs not connected (high impedance)
        self.Brake = 0     #  Brake: out1 = out2 = PGND  (both outputs conn. to GND)

    # motor.go(80)          # Forward, 80% speed
    # motor.go(0)           # Brake,  (both motor outputs connected to GND)
    #   or motor.go(motor.Brake)
    # motor.go(-100)        # Backward, full speed
    # motor.go(None)        # Stop, (both motor outputs high impedance)
    #   or motor.go(motor.Stop)
    #
    def go(self, speed):
        if speed is not None:
            self.pwm2.duty_u16(65535 - min(int(speed*655.35), 65535) if speed > 0 else 65535)  # we somewhat rely on the pin being
            self.pwm1.duty_u16(65535 - min(int(-speed*655.35), 65535) if speed < 0 else 65535) # high at duty_u16(65535)
        else:
            self.pwm1.duty_u16(0)
            self.pwm2.duty_u16(0)

The 8871 pwm.go() function will be changed to use inverted PWM mode, which assures that the pin signals are 1 at duty_u16(0) (see the above mentioned PWM: Reduce inconsistencies between ports. #10817)

I'm somewhat missing a feedback.
Are you o.k. with the just one pwm.go() function?
Now I also reduced the number of arguments to one as you see in the comments of this function.
I plan to check more chips/interface versions and name them, so that the submodules will be named accordingly and we can
collect a list of chips that behave according to the respective version.

[rkompass]

On the PWM side there is much clarity now because of the discussion in PWM: Reduce inconsistencies between ports. PWM: Reduce inconsistencies between ports. https://github.com/micropython/micropython/issues/10817)) .
My next questions/decisions to potentially being discussed are:

• The Pin objects now all are expected as pin objects. The HBridge classes do the change to PWM mode internally.
  Some drivers do this with 2 pins. I think about adding a HBridge.deinit() function that does the pwm.deinit() again.
  It might seem simpler and more natural to expect PWM objects and leave that to the user.
  Then also the frequency default setting would be obsolete.
• Do we need a str() or __repr__() function?

After studying the different interfaces which I encountered so far, which are summarized here:

#  ---  ININ_PWM Interface, used by TB6612  ---
#
#  in2 | in1 | pwm | (stby <--- common for both H-bridges, not used by the)
# -----------------------
#   X  |  X  |  X  |  L    Stop   (free running motor stop, i.e. high impedance)
# -----------------------
#   L  |  L  |  L  |  H    ????   (missing in datasheet)
#   L  |  L  |  H  |  H    Stop   (high impedance)
# -----------------------
#   L  |  H  |  L  |  H    Brake  (fast motor stop)
#   L  |  H  |  H  |  H    Forward
#   H  |  L  |  L  |  H    Brake  (fast motor stop)
#   H  |  L  |  H  |  H    Reverse
# -----------------------
#   H  |  H  |  X  |  H    Brake  (fast motor stop)
#
#  If the ININ_PWM Interface is reduced by setting pwm = high it saves 1 cable/pin per motor.
#      v--- it turns into the IN_IN interface, Pololu used that with the 6612 in the 3pi
#
#   in2 | in1 | (stby   <--- common for both H-bridges)
#  ------------------
#    X  |  X  |  L      Stop / Coast  (free running motor stop, i.e. high impedance)
#  ------------------
#    L  |  L  |  H      Stop / Coast   (high impedance)
#    L  |  H  |  H      Forward
#    H  |  L  |  H      Reverse
#    H  |  H  |  H      Brake  (fast motor stop)
#

#  ---  IN_IN Interface, used by DRV8871 and DRV8837  ---
#
#   in2 | in1 | (en  <---  no enable with DRV8871 ) en is called nSleep in the DRV8837 datasheet
#  ------------------
#    X  |  X  |  L      Stop / Coast (free running motor stop, i.e. high impedance)
#  ------------------
#    L  |  L  |  H      Stop / Coast (free running motor stop, i.e. high impedance)
#    L  |  H  |  H      Forward
#    H  |  L  |  H      Reverse
#    H  |  H  |  H      Brake  (fast motor stop)

#   ---  IN_IN_2B (doubled Brake) Interface, used by L298, L293 and L9110  ---
#
#   in2 | in1 | (en     <--- no enable pin with L9110)
#  ------------------
#    X  |  X  |  L      Stop   (free running motor stop, i.e. high impedance)
#  ------------------
#    L  |  L  |  H      Brake  (fast motor stop)
#    L  |  H  |  H      Forward
#    H  |  L  |  H      Reverse
#    H  |  H  |  H      Brake  (fast motor stop)

#   ---  PH_PWM Interface, used by DRV8838  ---
#         called PHASE/ENABLE interface in the Datasheet       
#
#    ph |  en | nSleep  <--- terms in the datasheet
#    ph | pwm | nsl     <--- terms in this driver
#  ------------------
#    X  |  X  |  L      Coast/Stop (high impedance)
#  ------------------
#    X  |  L  |  H      Brake  (fast motor stop)
#    L  |  H  |  H      Forward
#    H  |  H  |  H      Reverse

I decide to dedicate the ININ_PWM driver into an extra file. It is needed only for the 6612 and only if you want to economize on PWM pins (uses 1 per motor) and have many pins available (uses 3 per motor) in total. The reduction to IN_IN interface should be standard. This saves 1 pin per motor which should be of importance if you consider that for location/speed measurements via quadratic encoder you need 2 extra pins again per motor.
This leaves us with 3 interface versions of the driver. I will try to put IN_IN_2B as a variant of IN_IN so that in the end we
have 2 driver classes left, which hopefully cover much of the available hardware.

[rkompass]

The resulting code was:

from machine import Pin, PWM

class HBr_IN_IN:

    # The class initializer receives the direction pins as a 2-tuple or 2-list:
    # motor = HBr_IN_IN((in1, in2),  en=enA)                   #  or
    # motor = HBr_IN_IN(reversed((in1, in2)), freq = 2000)     #  for exchange of Clockwise and CounterClw
    #                                                            #  and user defined PWM frequency
    def __init__(self, in12, en=None, freq=1000):
        in12 = tuple(in12)   # make a tuple again in case we got a generator from reversed()
        self.pwm1 = PWM(in12[0], freq=freq, duty_u16=0, invert=True)
        self.pwm2 = PWM(in12[1], freq=freq, duty_u16=0, invert=True)  # .. and we are in Brake mode now
        self.en = en
        if en is not None:  
            self.en.init(mode=Pin.OUT, value=1)
        # --  Constants for Modes of the HBridge298.go() function:  --
        self.Stop = None   #  Both outputs not connected (high impedance)
        self.Brake = 0     #  Brake: out1 = out2 = PGND  (both outputs conn. to GND)

    def go(self, speed):
        if speed is not None:            # Other than Stop mode: Enforce inverted PWM mode.
            self.pwm2.init(duty_u16 = min(int(speed*655.35), 65535) if speed > 0 else 0, invert=True)  # We rely on the pin being high at
            self.pwm1.init(duty_u16 = min(int(-speed*655.35), 65535) if speed < 0 else 0, invert=True) #   duty_u16(0), with invert=True.
        else:       # We set the Stop mode by setting both pins=low and have to leave the inverted PWM mode for that.
            self.pwm1.init(duty_u16 = 0, invert=False)  # We rely on the pin being low at
            self.pwm2.init(duty_u16 = 0, invert=False)  #   duty_u16(0), with invert=False.
        if self.en is not None:          # Use also the enable Pin for Stop mode if it is there
            self.en(0 if speed is None else 1)


class HBr_PH_PWM:

    # The class initializer has an optional invert argument: invert=True exchanges Clockwise and CounterClw
    #     motor = HBr_PH_PWM(ph, en)                    # or
    #     motor = HBr_PH_PWM(ph, en, nsl)               # for inclusion of the sSleep Pin for Coast/Stop mode setting
    #     motor = HBr_PH_PWM(ph, en, invert=True, freq = 1000)  # for exchange of Clockwise and CounterClw
    #                                                            #    and explicit setting of PWM frequency
    def __init__(self, ph, pwm, nsl=None, invert=True, freq=1000):
        self.ph = ph
        self.ph.init(mode=Pin.OUT, value=0)
        self.pwm = PWM(pwm, freq=freq, duty_u16=0)   # will be permanently low at the start
        self.nsl = nsl
        if nsl is not None:
            self.nsl.init(mode=Pin.OUT, value=1)
        self.inv = bool(invert)
        #  --  Constants for Modes of the HBridge6612.go() function:  --
        self.Stop = None     #  Both outputs not connected (high impedance)
        self.Brake = 0       #  Brake: out1 = out2 = PGND  (both outputs conn. to GND)

    def go(self, speed):
        if speed is not None:            # Other than Stop mode
            self.ph((speed > 0) == self.inv)                  # self.ph(True) switches to high)
            self.pwm.duty_u16(min(int(abs(speed)*655.35), 65535))
        if self.nsl is not None:
            self.nsl(1 if speed is not None else 0)

See the above thoughts.

[rkompass]

Then I unified the class to one...
Now the class takes either two PWM objects and sets the interface to IN-IN mode or a Pin and a PWM object and switches to PH-PWM mode.
Advantages are: One HBridge class fits all, at least those interfaces inspected so far.
With the PWM objects passed there is no need for a deinit() member function. All that's needed is to del the motor object (and of course deinit the PWM objects that were passed, but that's the responsibility of the caller anyway).
With this code it is nearly impossible to code a __repr__() function though. Every platform has a different repr() of the PWM and it's very cumbersome to retrieve the Pins from those.

Code:

from machine import Pin, PWM

class HBridge:

    # The class init args are PWM objects in1 and in2 and an optional enable Pin object: --> IN-IN interface mode
    #  motor = HBridge(in1, in2,  en=enA)                  #  or
    #  motor = HBridge(in1, in2, invert=True, freq = 2000  #  Change of Clockwise/CounterClw and user defined PWM freq.
    #
    # The class init args are Pin object ph, PWM object pwm and an opt. enable Pin object: --> PH-PWM interface mode
    #  motor = HBridge(ph, pwm)                            # or
    #  motor = HBridge(ph, pwm, en=nsl)                    # for inclusion of the sSleep Pin for Coast/Stop mode setting
    #  motor = HBridge(ph, pwm, invert=True, freq = 1000)  # Change of Clockwise/CounterClw and user defined PWM freq.
    #
    def __init__(self, o1, o2, en=None, invert=False, freq=1000):
        if isinstance(o2, PWM):
            if isinstance(o1, PWM):     # ----------   IN-IN-Interface   --------
                self.if_in_in = 1   # interface in-in 
                self.pwm1 = o2 if invert else o1
                self.pwm2 = o1 if invert else o2
                self.pwm1.init(freq=freq, duty_u16=0, invert=True)
                self.pwm2.init(freq=freq, duty_u16=0, invert=True)  # and we are in Brake mode now
            elif isinstance(o1, Pin):  # ----------    PH-PWM-Interface   --------
                self.if_in_in = 0   # not interface in-in 
                self.ph = o1
                self.ph.init(mode=Pin.OUT, value=0)
                self.inv = bool(invert)
                self.pwm = o2
                self.pwm.init(freq=freq, duty_u16=0)   # will be permanently low at the start
            else:
                self.if_in_in = -1  # Error: no interface
        else:
            self.if_in_in = -1  # Error
        if self.if_in_in < 0:
            raise ValueError('HBridge: First args of type PWM, PWM or Pin, PWM expected')
        self.en = en
        if en is not None:  
            self.en.init(mode=Pin.OUT, value=1)
        # -----  Constants for Modes of the HBridge.go() function:  ------
        self.Stop = None   #  Both outputs not connected (high impedance)
        self.Brake = 0     #  Brake: out1 = out2 = PGND  (both outputs conn. to GND)

    def go(self, speed):
        if self.if_in_in:            # ----------   IN-IN-Interface   --------
            if speed is not None:            # Other than Stop mode: Enforce inverted PWM mode.
                self.pwm2.init(duty_u16 = min(int(speed*655.35), 65535) if speed > 0 else 0, invert=True)  # We rely on the pin being high at
                self.pwm1.init(duty_u16 = min(int(-speed*655.35), 65535) if speed < 0 else 0, invert=True) #   duty_u16(0), with invert=True.
            else:       # We set the Stop mode by setting both pins=low and have to leave the inverted PWM mode for that.
                self.pwm1.init(duty_u16 = 0, invert=False)  # We rely on the pin being low at
                self.pwm2.init(duty_u16 = 0, invert=False)  #   duty_u16(0), with invert=False.
        else:                        # ----------    PH-PWM-Interface   --------
            if speed is not None:            # Other than Stop mode
                self.ph((speed > 0) == self.inv)            # self.ph(True) switches to high.
                self.pwm.duty_u16(min(int(abs(speed)*655.35), 65535))
        if self.en is not None:      # In both Interfaces: Use also the enable Pin for Stop mode if it is there.
            self.en(0 if speed is None else 1)

[robert-hh]

Sorry for not commenting. I never worked with H-Bridges, so I cannot really tell what is useful and what not. As of the use of PWM, the above code looks reasonable. Consider that it will not work with the actual MP images, since at the moment invert is available only at the SAMD and MIMXRT port, and SAMD and RP2 have no init() method. invert() is not planned yet for ESP8266 and the nrf51xxx devices.

[IhorNehrutsa]

It look like HBridge arguments as pin number/names are more shorter/robust and simple in using than Pin/PWM objects arguments.

• HBridgeXXX uses the pin number/names and initializes the Pin/PWM objects inside itself once:

class HBridgeXXX:
    def __init__(self, pwm, ain1, ain2):
        self._ain1 = Pin(ain1, mode=Pin.OUT, value=0)
        self._ain2 = Pin(ain1, mode=Pin.OUT, value=0)
        self._pwm = PWM(Pin(pwm), freq=1_000, duty_u16=0)
        
# simply and safely
hBridgeXXX = HBridgeXXX(12, 13, 14)  

• HBridgeYYY uses the Pin/PWM objects and forced to reinitialize objects once more:

class HBridgeYYY:
    def __init__(self, pwm: PWM, ain1: Pin, ain2: Pin):
        self._pwm = pwm
        self._ain1 = ain1
        self._ain2 = ain2

        self._pwm.init(freq=1_000, duty_u16=0)  # reinit
        self._ain1.init(mode=Pin.OUT, value=0)  # reinit
        self._ain2.init(mode=Pin.OUT, value=0)  # reinit

# more complicated and there is a risk of improper initialization and unexpected switching on the outputs
pwm = PWM(12, freq=1_000, duty_u16=0))  # init
ain1 = Pin(13, mode=Pin.OUT, value=0)  # init
ain2 = Pin(14, mode=Pin.OUT, value=0)  # init
hBridgeYYY = HBridgeYYY(pwm, ain1, ain2) 

HBridgeYYY requires more competence from users.
I'd prefer the HBridgeXXX arguments style.

[IhorNehrutsa]

@sosi-deadeye
I think reverse is a better argument name than invert.

If TB6612 are different from L298, then there will be different HBridgeTB6612 and HBridgeL298 classes.

[IhorNehrutsa]

@rkompass
That display of posts in the discussion turned out to be a surprise for me.
May you separate posts?

I'd prefer to have several simple modules with one class HBridgeXXX inside and similar methods.
Then:

from hBridgeXXX_module import HBridgeXXX as HBridge

hBridge = HBridge()

[rkompass]

Thank you. I see. You got no notification at the subsequent postings?

[IhorNehrutsa]

Hi @sosi-deadeye @rkompass

Last week I developed two H-Bridge drivers:
PWM/Dir H-Bridge driver
and
4PWM H-Bridge driver
in branch
https://github.com/IhorNehrutsa/micropython-lib/tree/Full_H-Bridge

Could you review the README.md and *.py files?
Any suggestion is welcome, please.

Would you be interested in collaborating on work?
I propose you clone the Full_H-Bridge branch and create a pull request to it with your code for TB6612, DRV88XX, L29X, L9110, etc.
I will merge it together and then open a pull request to the master https://github.com/micropython/micropython-lib.
I hope that the co-work of the three authors is more powerful and will be approved faster in the main repository.

Thanks a lot.

[rkompass]

Hi @IhorNehrutsa

I will have a closer look next week.

[IhorNehrutsa]

Also you may intersted in Add Stepper Motor PWM-Counter driver