adding stepper motor

Author: jposada202020

README.rst

@@ -32,9 +32,6 @@ This library can work with other MCU (Not tested) that used the following PWM me
 * freq
 * duty_u16
 
-Sadly do not have the hardware to test the step motor part of the library so, this will
-be an exercise for the reader.:)
-
 
 Installing with mip
 ====================

docs/api.rst

@@ -7,3 +7,9 @@ MicroPython MOTOR Library
 
 .. automodule:: micropython_motor.motor
     :members:
+
+.. automodule:: micropython_motor.servo
+    :members:
+
+.. automodule:: micropython_motor.stepper
+    :members:

docs/conf.py

@@ -182,9 +182,6 @@
         "override": True,
     },
 ]
-python_type_aliases = {
-    "DigitalInOut": "digitalio.DigitalInOut",
-}
 
 object_description_options = [
     ("py:.*", dict(generate_synopses="first_sentence")),

docs/examples.rst

@@ -1,8 +1,26 @@
-Simple test
+Motor test
 ------------
 
-Ensure your device works with this simple test.
+DC motor simple test
 
 .. literalinclude:: ../examples/motor_simpletest.py
     :caption: examples/motor_simpletest.py
-    :lines: 5-
+    :lines: 10-
+
+Servo test
+------------
+
+Servo Simple Test
+
+.. literalinclude:: ../examples/servo_simpletest.py
+    :caption: examples/servo_simpletest.py
+    :lines: 6-
+
+Step Motor test
+--------------------
+
+Stepper Motor Test
+
+.. literalinclude:: ../examples/stepper_simpletest.py
+    :caption: examples/stepper_simpletest.py
+    :lines: 13-

examples.json

@@ -7,6 +7,10 @@
     [
       "micropython_motor/examples/motor_simpletest.py",
       "github:jposada202020/MicroPython_MOTOR/examples/motor_simpletest.py"
+    ],
+    [
+      "micropython_motor/examples/stepper_simpletest.py",
+      "github:jposada202020/MicroPython_MOTOR/examples/stepper_simpletest.py"
     ]
   ],
   "version": "1"

examples/stepper_simpletest.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2021 jedgarpark for Adafruit Industries
+# SPDX-FileCopyrightText: Copyright (c) 2023 Jose D. Montoya
+#
+# SPDX-License-Identifier: MIT
+
+"""Example adapted from https://learn.adafruit.com/use-dc-stepper-servo-motor-solenoid-rp2040-pico/stepper-motor"""
+
+# Hardware setup:
+#   Stepper motor via DRV8833 driver breakout on GP21, GP20, GP19, GP18
+#   external power supply
+#   DRV8833 Enabled on GP16
+
+import time
+from machine import PWM, Pin
+from micropython_motor import stepper
+
+print("Stepper test")
+
+
+mode = -1
+
+# Mode button setup
+drv_switch = Pin(16, Pin.OUT)
+drv_switch.on()
+
+# Stepper motor setup
+DELAY = 0.006  # fastest is ~ 0.004, 0.01 is still very smooth, gets steppy after that
+STEPS = 513  # this is a full 360º
+coils = (Pin(21, Pin.OUT), Pin(20, Pin.OUT), Pin(19, Pin.OUT), Pin(18, Pin.OUT))
+
+
+stepper_motor = stepper.StepperMotor(
+    coils[0], coils[1], coils[2], coils[3], microsteps=None
+)
+
+
+def stepper_fwd():
+    print("stepper forward")
+    for _ in range(STEPS):
+        stepper_motor.onestep(direction=stepper.FORWARD)
+        time.sleep(DELAY)
+    stepper_motor.release()
+
+
+def stepper_back():
+    print("stepper backward")
+    for _ in range(STEPS):
+        stepper_motor.onestep(direction=stepper.BACKWARD)
+        time.sleep(DELAY)
+    stepper_motor.release()
+
+
+def run_test(testnum):
+    if testnum is 0:
+        stepper_fwd()
+    elif testnum is 1:
+        stepper_back()
+
+
+while True:
+    mode = (mode + 1) % 2
+    print("switch to mode %d" % (mode))
+    print()
+    time.sleep(0.8)  # big debounce
+    run_test(mode)

micropython_motor/__init__.py

@@ -4,3 +4,4 @@
 
 from .servo import Servo
 from .motor import MOTOR
+from .stepper import StepperMotor

micropython_motor/servo.py

@@ -3,7 +3,7 @@
 #
 # SPDX-License-Identifier: MIT
 """
-`motor`
+`servo`
 ================================================================================
 
 MicroPython Helper for controlling PWM based servos

micropython_motor/stepper.py

@@ -0,0 +1,191 @@
+# SPDX-FileCopyrightText: 2017 Scott Shawcroft  for Adafruit Industries
+# SPDX-FileCopyrightText: Copyright (c) 2023 Jose D. Montoya
+#
+# SPDX-License-Identifier: MIT
+
+"""
+`stepper`
+====================================================
+
+MicroPython Helper for controlling stepper motors with microstepping support.
+
+
+* Author(s): Tony DiCola, Scott Shawcroft, Jose D. Montoya
+"""
+
+import math
+from micropython import const
+
+
+# Constants that specify the direction and style of steps.
+FORWARD = const(1)
+"""Step forward"""
+BACKWARD = const(2)
+""""Step backward"""
+SINGLE = const(1)
+"""Step so that each step only activates a single coil"""
+DOUBLE = const(2)
+"""Step so that each step only activates two coils to produce more torque."""
+INTERLEAVE = const(3)
+"""Step half a step to alternate between single coil and double coil steps."""
+MICROSTEP = const(4)
+"""Step a fraction of a step by partially activating two neighboring coils. Step size is determined
+   by ``microsteps`` constructor argument."""
+
+_SINGLE_STEPS = bytes([0b0010, 0b0100, 0b0001, 0b1000])
+
+_DOUBLE_STEPS = bytes([0b1010, 0b0110, 0b0101, 0b1001])
+
+_INTERLEAVE_STEPS = bytes(
+    [0b1010, 0b0010, 0b0110, 0b0100, 0b0101, 0b0001, 0b1001, 0b1000]
+)
+
+
+class StepperMotor:
+    """A bipolar stepper motor or four coil unipolar motor. The use of microstepping requires
+    pins that can output PWM. For non-microstepping, can set microsteps to None and use
+    digital out pins.
+
+
+    :param ain1: `machine.PWM` or `machine.Pin`-compatible output connected to the driver for
+      the first coil (unipolar) or first input to first coil (bipolar).
+    :param  ain2: `machine.PWM` or `machine.Pin`-compatible output connected to the driver for
+      the third coil (unipolar) or second input to first coil (bipolar).
+    :param bin1: `machine.PWM` or `machine.Pin`-compatible output connected to the driver for
+      the second coil (unipolar) or second input to second coil (bipolar).
+    :param bin2: `machine.PWM` or `machine.Pin`-compatible output connected to the driver for
+      the fourth coil (unipolar) or second input to second coil (bipolar).
+    :param int microsteps: Number of microsteps between full steps. Must be at least 2 and even.
+
+    """
+
+    def __init__(self, ain1, ain2, bin1, bin2, *, microsteps=16) -> None:
+        if microsteps is None:
+            # Digital IO Pins
+            self._steps = None
+            self._coil = (ain1, ain2, bin1, bin2)
+        else:
+            # PWM Pins set a safe pwm freq for each output
+            self._coil = (ain2, bin1, ain1, bin2)
+            for i in range(4):
+                if self._coil[i].freq() < 1500:
+                    try:
+                        self._coil[i].frequency = 2000
+                    except AttributeError as err:
+                        raise ValueError(
+                            "PWMOut outputs must either be set to at least "
+                            "1500 Hz or allow variable frequency."
+                        ) from err
+            if microsteps < 2:
+                raise ValueError("Microsteps must be at least 2")
+            if microsteps % 2 == 1:
+                raise ValueError("Microsteps must be even")
+            self._curve = [
+                int(round(0xFFFF * math.sin(math.pi / (2 * microsteps) * i)))
+                for i in range(microsteps + 1)
+            ]
+        self._current_microstep = 0
+        self._microsteps = microsteps
+        self._update_coils()
+
+    def _update_coils(self, *, microstepping: bool = False) -> None:
+        if self._microsteps is None:
+            # Digital IO Pins Get coil activation sequence
+            if self._steps is None:
+                steps = 0b0000
+            else:
+                steps = self._steps[self._current_microstep % len(self._steps)]
+            # Energize coils as appropriate:
+            for i, coil in enumerate(self._coil):
+                coil.value((steps >> i) & 0x01)
+        else:
+            # PWM Pins
+            duty_cycles = [0, 0, 0, 0]
+            trailing_coil = (self._current_microstep // self._microsteps) % 4
+            leading_coil = (trailing_coil + 1) % 4
+            microstep = self._current_microstep % self._microsteps
+            duty_cycles[leading_coil] = self._curve[microstep]
+            duty_cycles[trailing_coil] = self._curve[self._microsteps - microstep]
+
+            # This ensures DOUBLE steps use full torque. Without it, we'd use
+            #  partial torque from the microstepping curve (0xb504).
+            if not microstepping and (
+                duty_cycles[leading_coil] == duty_cycles[trailing_coil]
+                and duty_cycles[leading_coil] > 0
+            ):
+                duty_cycles[leading_coil] = 0xFFFF
+                duty_cycles[trailing_coil] = 0xFFFF
+
+            # Energize coils as appropriate:
+            for i in range(4):
+                self._coil[i].duty_u16(duty_cycles[i])
+
+    def release(self) -> None:
+        """Releases all the coils so the motor can free spin, also won't use any power"""
+        # De-energize coils:
+        for coil in self._coil:
+            if self._microsteps is None:
+                coil.value(0)
+            else:
+                coil.duty_u16(0)
+
+    def onestep(self, *, direction: int = FORWARD, style: int = SINGLE) -> None:
+        """Performs one step of a particular style. The actual rotation amount will vary by style.
+        `SINGLE` and `DOUBLE` will normal cause a full step rotation. `INTERLEAVE` will normally
+        do a half step rotation. `MICROSTEP` will perform the smallest configured step.
+
+        When step styles are mixed, subsequent `SINGLE`, `DOUBLE` or `INTERLEAVE` steps may be
+        less than normal in order to align to the desired style's pattern.
+
+        :param int direction: Either `FORWARD` or `BACKWARD`
+        :param int style: `SINGLE`, `DOUBLE`, `INTERLEAVE`"""
+        if self._microsteps is None:
+            # Digital IO Pins
+            step_size = 1
+            if style == SINGLE:
+                self._steps = _SINGLE_STEPS
+            elif style == DOUBLE:
+                self._steps = _DOUBLE_STEPS
+            elif style == INTERLEAVE:
+                self._steps = _INTERLEAVE_STEPS
+            else:
+                raise ValueError("Unsupported step style.")
+        else:
+            # PWM Pins Adjust current steps based on the direction and type of step.
+            step_size = 0
+            if style == MICROSTEP:
+                step_size = 1
+            else:
+                half_step = self._microsteps // 2
+                full_step = self._microsteps
+                # Its possible the previous steps were MICROSTEPS so first align
+                #  with the interleave pattern.
+                additional_microsteps = self._current_microstep % half_step
+                if additional_microsteps != 0:
+                    # We set _current_microstep directly because our step size varies
+                    # depending on the direction.
+                    if direction == FORWARD:
+                        self._current_microstep += half_step - additional_microsteps
+                    else:
+                        self._current_microstep -= additional_microsteps
+                    step_size = 0
+                elif style == INTERLEAVE:
+                    step_size = half_step
+
+                current_interleave = self._current_microstep // half_step
+                if (style == SINGLE and current_interleave % 2 == 1) or (
+                    style == DOUBLE and current_interleave % 2 == 0
+                ):
+                    step_size = half_step
+                elif style in (SINGLE, DOUBLE):
+                    step_size = full_step
+
+        if direction == FORWARD:
+            self._current_microstep += step_size
+        else:
+            self._current_microstep -= step_size
+
+        # Now that we know our target microstep we can determine how to energize the four coils.
+        self._update_coils(microstepping=style == MICROSTEP)
+
+        return self._current_microstep

package.json

@@ -11,6 +11,10 @@
     [
       "micropython_motor/servo.py",
       "github:jposada202020/MicroPython_MOTOR/micropython_motor/servo.py"
+    ],
+    [
+      "micropython_motor/stepper.py",
+      "github:jposada202020/MicroPython_MOTOR/micropython_motor/stepper.py"
     ]
   ],
   "version": "1"