Add stepper motor support with tests.

Also, lints everything.

Author: tannewt

.gitignore

@@ -4,3 +4,4 @@ _build
 .env
 build*
 bundles
+.cache

.travis.yml

@@ -22,9 +22,11 @@ deploy:
     tags: true
 
 install:
-  - pip install pylint circuitpython-build-tools
+  - pip install pylint circuitpython-build-tools pytest
 
 script:
-  - pylint adafruit_motor.py
+  - py.tests
+  - pylint adafruit_motor/*.py
   - ([[ ! -d "examples" ]] || pylint --disable=missing-docstring,invalid-name examples/*.py)
+  - ([[ ! -d "tests" ]] || pylint --disable=missing-docstring tests/*.py)
   - circuitpython-build-bundles --filename_prefix adafruit-circuitpython-motor --library_location .

adafruit_motor/motor.py

@@ -37,7 +37,7 @@
 """
 
 __version__ = "0.0.0-auto.0"
-__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_motor.git"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Motor.git"
 
 class DCMotor:
     """DC motor driver. ``positive_pwm`` and ``negative_pwm`` can be swapped if the motor runs in

adafruit_motor/servo.py

@@ -29,14 +29,12 @@
 * Author(s): Scott Shawcroft
 """
 
-# imports
-
 __version__ = "0.0.0-auto.0"
-__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_motor.git"
-
-import math
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Motor.git"
 
-class _BaseServo:
+# We disable the too few public methods check because this is a private base class for the two types
+# of servos.
+class _BaseServo: # pylint: disable-msg=too-few-public-methods
     """Shared base class that handles pulse output based on a value between 0 and 1.0
 
        :param int min_pulse: The minimum pulse length of the servo in microseconds.
@@ -47,7 +45,6 @@ def __init__(self, pwm_out, *, min_pulse=1000, max_pulse=2000):
         self._min_duty = int((min_pulse * pwm_out.frequency) / 1000000 * 0xffff)
         max_duty = (max_pulse * pwm_out.frequency) / 1000000 * 0xffff
         self._duty_range = int(max_duty - self._min_duty)
-        print(self._min_duty, self._duty_range)
         self._pwm_out = pwm_out
 
     @property
@@ -75,11 +72,11 @@ def __init__(self, pwm_out, *, actuation_range=180, min_pulse=1000, max_pulse=20
 
     @property
     def angle(self):
+        """The servo angle in degrees."""
         return self._actuation_range * self._fraction
 
     @angle.setter
     def angle(self, new_angle):
-        """The servo angle in degrees."""
         if new_angle < 0 or new_angle > self._actuation_range:
             raise ValueError("Angle out of range")
         self._fraction = new_angle / self._actuation_range

adafruit_motor/stepper.py

@@ -28,176 +28,126 @@
 * Author(s): Tony DiCola, Scott Shawcroft
 """
 
-# imports
+import math
+
+from micropython import const
 
 __version__ = "0.0.0-auto.0"
-__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_motor.git"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Motor.git"
 
 # Stepper Motor Shield/Wing Driver
 # Based on Adafruit Motorshield library:
 # https://github.com/adafruit/Adafruit_Motor_Shield_V2_Library
 
-
 # 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."""
 
-# Not a const so users can change this global to 8 or 16 to change step size
-MICROSTEPS = 16
-
-# Microstepping curves (these are constants but need to be tuples/indexable):
-_MICROSTEPCURVE8 = (0, 50, 98, 142, 180, 212, 236, 250, 255)
-_MICROSTEPCURVE16 = (0, 25, 50, 74, 98, 120, 141, 162, 180, 197, 212, 225, 236, 244, 250, 253, 255)
-
-# Define PWM outputs for each of two available steppers.
-# Each tuple defines for a stepper: pwma, ain2, ain1, pwmb, bin2, bin1
-_STEPPERS = ((8, 9, 10, 13, 12, 11), (2, 3, 4, 7, 6, 5))
+class StepperMotor:
+    """A bipolar stepper motor or four coil unipolar motor.
+
+    :param ~pulseio.PWMOut ain1: `PWMOut`-compatible output connected to the driver for the first
+      coil (unipolar) or first input to first coil (bipolar).
+    :param ~pulseio.PWMOut ain2: `PWMOut`-compatible output connected to the driver for the third
+      coil (unipolar) or second input to first coil (bipolar).
+    :param ~pulseio.PWMOut bin1: `PWMOut`-compatible output connected to the driver for the second
+      coil (unipolar) or second input to second coil (bipolar).
+    :param ~pulseio.PWMOut bin2: `PWMOut`-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):
+        self._coil = (ain2, bin1, ain1, bin2)
+
+        self._current_microstep = 0
+        if microsteps < 2:
+            raise ValueError("Microsteps must be at least 2")
+        if microsteps % 2 == 1:
+            raise ValueError("Microsteps must be even")
+        self._microsteps = microsteps
+        self._curve = [int(round(0xffff * math.sin(math.pi / (2 * microsteps) * i)))
+                       for i in range(microsteps + 1)]
+        self._update_coils()
+
+    def _update_coils(self, *, microstepping=False):
+        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):
+            print(i, hex(duty_cycles[i]))
+            self._coil[i].duty_cycle = duty_cycles[i]
 
-class StepperMotor:
-    def __init__(self, pca, pwma, ain2, ain1, pwmb, bin2, bin1):
-        self.pca9685 = pca
-        self.pwma = pwma
-        self.ain2 = ain2
-        self.ain1 = ain1
-        self.pwmb = pwmb
-        self.bin2 = bin2
-        self.bin1 = bin1
-        self.currentstep = 0
-
-    def _pwm(self, pin, value):
-        if value > 4095:
-            self.pca9685.pwm(pin, 4096, 0)
-        else:
-            self.pca9685.pwm(pin, 0, value)
+    def onestep(self, *, direction=FORWARD, style=SINGLE):
+        """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.
 
-    def _pin(self, pin, value):
-        if value:
-            self.pca9685.pwm(pin, 4096, 0)
-        else:
-            self.pca9685.pwm(pin, 0, 0)
+           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.
 
-    def onestep(self, direction, style):
-        ocra = 255
-        ocrb = 255
+           :param int direction: Either `FORWARD` or `BACKWARD`
+           :param int style: `SINGLE`, `DOUBLE`, `INTERLEAVE`"""
         # Adjust current steps based on the direction and type of step.
-        if style == SINGLE:
-            if (self.currentstep//(MICROSTEPS//2)) % 2:
-                if direction == FORWARD:
-                    self.currentstep += MICROSTEPS//2
-                else:
-                    self.currentstep -= MICROSTEPS//2
-            else:
-                if direction == FORWARD:
-                    self.currentstep += MICROSTEPS
-                else:
-                    self.currentstep -= MICROSTEPS
-        elif style == DOUBLE:
-            if not (self.currentstep//(MICROSTEPS//2)) % 2:
-                if direction == FORWARD:
-                    self.currentstep += MICROSTEPS//2
-                else:
-                    self.currentstep -= MICROSTEPS//2
-            else:
-                if direction == FORWARD:
-                    self.currentstep += MICROSTEPS
-                else:
-                    self.currentstep -= MICROSTEPS
-        elif style == INTERLEAVE:
-            if direction == FORWARD:
-                self.currentstep += MICROSTEPS//2
-            else:
-                self.currentstep -= MICROSTEPS//2
-        elif style == MICROSTEP:
-            if direction == FORWARD:
-                self.currentstep += 1
-            else:
-                self.currentstep -= 1
-            self.currentstep += MICROSTEPS*4
-            self.currentstep %= MICROSTEPS*4
-            ocra = 0
-            ocrb = 0
-            if MICROSTEPS == 8:
-                curve = _MICROSTEPCURVE8
-            elif MICROSTEPS == 16:
-                curve = _MICROSTEPCURVE16
-            else:
-                raise RuntimeError('MICROSTEPS must be 8 or 16!')
-            if 0 <= self.currentstep < MICROSTEPS:
-                ocra = curve[MICROSTEPS - self.currentstep]
-                ocrb = curve[self.currentstep]
-            elif MICROSTEPS <= self.currentstep < MICROSTEPS*2:
-                ocra = curve[self.currentstep - MICROSTEPS]
-                ocrb = curve[MICROSTEPS*2 - self.currentstep]
-            elif MICROSTEPS*2 <= self.currentstep < MICROSTEPS*3:
-                ocra = curve[MICROSTEPS*3 - self.currentstep]
-                ocrb = curve[self.currentstep - MICROSTEPS*2]
-            elif MICROSTEPS*3 <= self.currentstep < MICROSTEPS*4:
-                ocra = curve[self.currentstep - MICROSTEPS*3]
-                ocrb = curve[MICROSTEPS*4 - self.currentstep]
-        self.currentstep += MICROSTEPS*4
-        self.currentstep %= MICROSTEPS*4
-        # Set PWM outputs.
-        self._pwm(self.pwma, ocra*16)
-        self._pwm(self.pwmb, ocrb*16)
-        latch_state = 0
-        # Determine which coils to energize:
+        step_size = 0
         if style == MICROSTEP:
-            if 0 <= self.currentstep < MICROSTEPS:
-                latch_state |= 0x3
-            elif MICROSTEPS <= self.currentstep < MICROSTEPS*2:
-                latch_state |= 0x6
-            elif MICROSTEPS*2 <= self.currentstep < MICROSTEPS*3:
-                latch_state |= 0xC
-            elif MICROSTEPS*3 <= self.currentstep < MICROSTEPS*4:
-                latch_state |= 0x9
+            step_size = 1
         else:
-            latch_step = self.currentstep//(MICROSTEPS//2)
-            if latch_step == 0:
-                latch_state |= 0x1  # energize coil 1 only
-            elif latch_step == 1:
-                latch_state |= 0x3  # energize coil 1+2
-            elif latch_step == 2:
-                latch_state |= 0x2  # energize coil 2 only
-            elif latch_step == 3:
-                latch_state |= 0x6  # energize coil 2+3
-            elif latch_step == 4:
-                latch_state |= 0x4  # energize coil 3 only
-            elif latch_step == 5:
-                latch_state |= 0xC  # energize coil 3+4
-            elif latch_step == 6:
-                latch_state |= 0x8  # energize coil 4 only
-            elif latch_step == 7:
-                latch_state |= 0x9  # energize coil 1+4
-        # Energize coils as appropriate:
-        if latch_state & 0x1:
-            self._pin(self.ain2, True)
-        else:
-            self._pin(self.ain2, False)
-        if latch_state & 0x2:
-            self._pin(self.bin1, True)
-        else:
-            self._pin(self.bin1, False)
-        if latch_state & 0x4:
-            self._pin(self.ain1, True)
-        else:
-            self._pin(self.ain1, False)
-        if latch_state & 0x8:
-            self._pin(self.bin2, True)
+            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 == SINGLE or style == DOUBLE:
+                step_size = full_step
+
+        print(step_size, MICROSTEP)
+
+        if direction == FORWARD:
+            self._current_microstep += step_size
         else:
-            self._pin(self.bin2, False)
-        return self.currentstep
+            self._current_microstep -= step_size
 
+        print(self._current_microstep)
 
-class Steppers:
-    def __init__(self, i2c, address=0x60, freq=1600):
-        self.pca9685 = pca9685.PCA9685(i2c, address)
-        self.pca9685.freq(freq)
+        # Now that we know our target microstep we can determine how to energize the four coils.
+        self._update_coils(microstepping=style == MICROSTEP)
 
-    def get_stepper(self, num):
-        pwma, ain2, ain1, pwmb, bin2, bin1 = _STEPPERS[num]
-        return StepperMotor(self.pca9685, pwma, ain2, ain1, pwmb, bin2, bin1)
+        return self._current_microstep