ready to test

Author: dhalbert

README.rst

@@ -37,54 +37,46 @@ In most cases you just need a couple of imports.
 
   # This is a mock example showing typical usage of the library for each kind of device.
 
-  # crickit is a singleton object
-  from adafruit_crickit.crickit import crickit
-
-  # Terminals have simple names like SIGNAL1, SERVO2, TOUCH3, MOTOR1A, NEOPIXEL,
-  # CPX_DRIVE1, and FEATHER_DRIVE2.
-  # Because the Drive terminals are numbered in reverse on the CPX Crickit vs the FeatherWing Crickit,
-  # there are separate DRIVE names for CPX and FeatherWing Drive terminals.
-  from adafruit_crickit.terminals import (SERVO1,
-                                          MOTOR1A, MOTOR1B, MOTOR2A, MOTOR2B,
-                                          CPX_DRIVE1, NEOPIXEL, SIGNAL1, SIGNAL2, TOUCH1)
+  from adafruit_crickit import crickit
 
   # Add this import if using stepper motors.
   # It will expose constants saying how to step: stepper.FORWARD, stepper.BACKWARD, etc.
   from adafruit_motor import stepper
 
-  servo1 = crickit.servo(SERVO1)
-  servo1.angle = 90
+  # Set servo 1 to 90 degrees
+  crickit.servo_1.angle = 90
 
-  cservo1 = crickit.continuous_servo(SERVO1)
-  cservo1.throttle = -0.5
+  # Change servo settings.
+  crickit.servo_1.actuation_range = 135
+  crickit.servo_1.set_pulse_widths(min_pulse=850, max_pulse=2100)
 
-  motor = crickit.dc_motor(MOTOR1A, MOTOR1B)
-  motor.throttle = 0.5
+  # You can assign a device to a variable to get a shorter name.
+  servo_2 = crickit.servo_2
+  servo_2.throttle = 0
 
-  drive1 = crickit.pwm_out(CPX_DRIVE1)
-  drive1.fraction = 1.0
+  # Run a continous servo on Servo 2 backwards at half speed.
+  crickit.continuous_servo_2.throttle = -0.5
 
-  # Note: On CPX Crickit, NeoPixel pin is normally connected to A1, not to seesaw,
-  # so this demo would not control the NeoPixel terminal.
+  # Run the motor on Motor 1 terminals at half speed.
+  crickit.dc_motor_1.throttle = 0.5
 
-  # Strip or ring of 8 NeoPixels
-  neopixels = crickit.neopixel(NEOPIXEL, 8)
-  neopixels.fill((100, 100, 100))
+  # Set Drive 1 terminal to 3/4 strength.
+  crickit.drive_1.fraction = 0.75
 
-  # Write Signal terminal 1 and read Signal terminal 2.
-  ss = crickit.seesaw
-  ss.pin_mode(SIGNAL1, ss.OUTPUT)
-  ss.pin_mode(SIGNAL2, ss.INPUT)
-  ss.digital_write(SIGNAL1, True)
-  print(ss.digital_read(SIGNAL2))
+  if crickit.touch_1.value:
+      print("Touched terminal Touch 1")
 
   # A single stepper motor uses up all the motor terminals.
-  stepper_motor = crickit.stepper_motor(MOTOR1A, MOTOR1B, MOTOR2A, MOTOR2B)
-  stepper_motor.onestep(direction=stepper.FORWARD)
+  crickit.stepper_motor.onestep(direction=stepper.FORWARD)
 
-  touch1 = crickit.touch(TOUCH1)
-  if touch1.value:
-      print("Touched terminal Touch 1")
+  # You can also use the Drive terminals for a stepper motor
+  crickit.drive_stepper_motor.onestep(direction=stepper.BACKWARD)
+
+  # Note: On CPX Crickit, NeoPixel pin is normally connected to A1, not to seesaw,
+  # so this part of the demo cannot control the NeoPixel terminal.
+  # Strip or ring of 8 NeoPixels
+  crickit.init_neopixel(8)
+  crickit.neopixel.fill((100, 100, 100))
 
 
 Contributing

adafruit_crickit.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 """
-`adafruit_crickit.crickit`
+`adafruit_crickit`
 ==========================
 
 Convenience library for using the Adafruit Crickit robotics boards.
@@ -51,31 +51,14 @@
 #pylint: disable=wrong-import-position
 sys.path.insert(0, ".frozen")   # Prefer frozen modules over local.
 
-from adafruit_seesaw.seesaw import Seesaw
-from adafruit_seesaw.pwmout import PWMOut
+from adafruit_seesaw.seesaw import Seesaw, PWMOut
 from adafruit_motor.servo import Servo, ContinuousServo
 from adafruit_motor.motor import DCMotor
 from adafruit_motor.stepper import StepperMotor
 
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Crickit.git"
 
-SIGNAL1 = const(2)
-"""Signal 1 terminal"""
-SIGNAL2 = const(3)
-"""Signal 2 terminal"""
-SIGNAL3 = const(40)
-"""Signal 3 terminal"""
-SIGNAL4 = const(41)
-"""Signal 4 terminal"""
-SIGNAL5 = const(11)
-"""Signal 5 terminal"""
-SIGNAL6 = const(10)
-"""Signal 6 terminal"""
-SIGNAL7 = const(9)
-"""Signal 7 terminal"""
-SIGNAL8 = const(8)
-"""Signal 8 terminal"""
 
 _SERVO1 = const(17)
 _SERVO2 = const(16)
@@ -84,16 +67,14 @@
 
 _MOTOR1 = (22, 23)
 _MOTOR2 = (19, 18)
-_MOTOR = _MOTOR1 + _MOTOR2
+_MOTOR_ALL = _MOTOR1 + _MOTOR2
 
 _DRIVE1 = const(42)
 _DRIVE2 = const(43)
 _DRIVE3 = const(12)
 _DRIVE4 = const(13)
 
-_DRIVE_SET = (_DRIVE1, _DRIVE2, _DRIVE3, _DRIVE4)
-
-_PWM_SET = _MOTOR_SET | _SERVO_SET | _DRIVE_SET
+_DRIVE_ALL = (_DRIVE1, _DRIVE2, _DRIVE3, _DRIVE4)
 
 _TOUCH1 = const(4)
 _TOUCH2 = const(5)
@@ -121,13 +102,56 @@ def value(self):
         return self.raw_value > self.threshold
 
 
+#pylint: disable=too-many-public-methods
 class Crickit:
-    """Represents a Crickit board."""
+    """Represents a Crickit board. Provides a number of devices available via properties, such as
+    ``servo_1``. Devices are created on demand the first time they are referenced.
+
+    It's fine to refer a device multiple times via its property, but it's faster and results
+    in more compact code to assign a device to a variable.
+
+    .. code-block:: python
+
+      import time
+      from adafruit_crickit import crickit
+
+      # This is fine:
+      crickit.servo_1.angle = 0
+      time.sleep(1)
+      crickit.servo_1.angle = 90
+      time.sleep(1)
+
+      # This is slightly faster and more compact:
+      servo_1 = crickit.servo_1
+      servo_1.angle = 0
+      time.sleep(1)
+      servo_1.angle = 90
+      time.sleep(1)
+    """
+
+    SIGNAL1 = 2
+    """Signal 1 terminal"""
+    SIGNAL2 = 3
+    """Signal 2 terminal"""
+    SIGNAL3 = 40
+    """Signal 3 terminal"""
+    SIGNAL4 = 41
+    """Signal 4 terminal"""
+    SIGNAL5 = 11
+    """Signal 5 terminal"""
+    SIGNAL6 = 10
+    """Signal 6 terminal"""
+    SIGNAL7 = 9
+    """Signal 7 terminal"""
+    SIGNAL8 = 8
+    """Signal 8 terminal"""
+
     def __init__(self, seesaw):
         self._seesaw = seesaw
         # Associate terminal(s) with certain devices.
         # Used to find existing devices.
         self._devices = dict()
+        self._neopixel = None
 
     @property
     def seesaw(self):
@@ -148,42 +172,42 @@ def seesaw(self):
     @property
     def servo_1(self):
         """``adafruit_motor.servo.Servo`` object on Servo 1 terminal"""
-        return self._servo(_SERVO1)
+        return self._servo(_SERVO1, Servo)
 
     @property
     def servo_2(self):
         """``adafruit_motor.servo.Servo`` object on Servo 2 terminal"""
-        return self._servo(_SERVO2)
+        return self._servo(_SERVO2, Servo)
 
     @property
     def servo_3(self):
         """``adafruit_motor.servo.Servo`` object on Servo 3 terminal"""
-        return self._servo(_SERVO3)
+        return self._servo(_SERVO3, Servo)
 
     @property
     def servo_4(self):
         """``adafruit_motor.servo.Servo`` object on Servo 4 terminal"""
-        return self._servo(_SERVO4)
+        return self._servo(_SERVO4, Servo)
 
     @property
-    def continous_servo_1(self):
-        """``adafruit_motor.servo.Continous_Servo`` object on Servo 1 terminal"""
-        return self._servo(_SERVO1, Continous_Servo)
+    def continuous_servo_1(self):
+        """``adafruit_motor.servo.ContinuousServo`` object on Servo 1 terminal"""
+        return self._servo(_SERVO1, ContinuousServo)
 
     @property
-    def continous_servo_2(self):
-        """``adafruit_motor.servo.Continous_Servo`` object on Servo 2 terminal"""
-        return self._servo(_SERVO2, Continous_Servo)
+    def continuous_servo_2(self):
+        """``adafruit_motor.servo.ContinuousServo`` object on Servo 2 terminal"""
+        return self._servo(_SERVO2, ContinuousServo)
 
     @property
     def continuous_servo_3(self):
-        """``adafruit_motor.servo.Continuous_Servo`` object on Servo 3 terminal"""
-        return self._servo(_SERVO3, Continuous_Servo)
+        """``adafruit_motor.servo.ContinuousServo`` object on Servo 3 terminal"""
+        return self._servo(_SERVO3, ContinuousServo)
 
     @property
     def continuous_servo_4(self):
-        """``adafruit_motor.servo.Continuous_Servo`` object on Servo 4 terminal"""
-        return self._servo(_SERVO4, Continuous_Servo)
+        """``adafruit_motor.servo.ContinuousServo`` object on Servo 4 terminal"""
+        return self._servo(_SERVO4, ContinuousServo)
 
     def _servo(self, terminal, servo_class):
         device = self._devices.get(terminal, None)
@@ -195,56 +219,56 @@ def _servo(self, terminal, servo_class):
         return device
 
     @property
-    def motor_1(self):
+    def dc_motor_1(self):
         """``adafruit_motor.motor.DCMotor`` object on Motor 1 terminals"""
         return self._motor(_MOTOR1, DCMotor)
 
     @property
-    def motor_2(self):
+    def dc_motor_2(self):
         """``adafruit_motor.motor.DCMotor`` object on Motor 2 terminals"""
         return self._motor(_MOTOR2, DCMotor)
 
     @property
     def stepper_motor(self):
         """``adafruit_motor.motor.StepperMotor`` object on Motor 1 and Motor 2 terminals"""
-        return self._stepper_motor(_MOTOR_ALL, StepperMotor)
+        return self._motor(_MOTOR_ALL, StepperMotor)
 
     @property
     def drive_stepper_motor(self):
         """``adafruit_motor.motor.StepperMotor`` object on Drive terminals"""
-        return self._stepper_motor(_DRIVE_ALL, StepperMotor)
+        return self._motor(_DRIVE_ALL, StepperMotor)
 
     @property
     def feather_drive_stepper_motor(self):
         """``adafruit_motor.motor.StepperMotor`` object on Drive terminals on Crickit FeatherWing"""
-        return self._stepper_motor(reversed(_DRIVE_ALL), StepperMotor)
+        return self._motor(reversed(_DRIVE_ALL), StepperMotor)
 
     def _motor(self, terminals, motor_class):
         device = self._devices.get(terminals, None)
         if not isinstance(device, motor_class):
             device = motor_class(*(PWMOut(self._seesaw, terminal) for terminal in terminals))
-            self._devices[terminal] = device
+            self._devices[terminals] = device
         return device
 
     @property
     def drive_1(self):
         """``adafruit_seesaw.pwmout.PWMOut`` object on Drive 1 terminal, with ``frequency=1000``"""
-        return _drive(_DRIVE1)
+        return self._drive(_DRIVE1)
 
     @property
     def drive_2(self):
         """``adafruit_seesaw.pwmout.PWMOut`` object on Drive 2 terminal, with ``frequency=1000``"""
-        return _drive(_DRIVE2)
+        return self._drive(_DRIVE2)
 
     @property
     def drive_3(self):
         """``adafruit_seesaw.pwmout.PWMOut`` object on Drive 3 terminal, with ``frequency=1000``"""
-        return _drive(_DRIVE3)
+        return self._drive(_DRIVE3)
 
     @property
     def drive_4(self):
         """``adafruit_seesaw.pwmout.PWMOut`` object on Drive 4 terminal, with ``frequency=1000``"""
-        return _drive(_DRIVE4)
+        return self._drive(_DRIVE4)
 
     feather_drive_1 = drive_4
     """``adafruit_seesaw.pwmout.PWMOut`` object on Crickit Featherwing Drive 1 terminal,
@@ -264,7 +288,7 @@ def drive_4(self):
     """
 
     def _drive(self, terminal):
-        device = self._devices.get(terminals, None)
+        device = self._devices.get(terminal, None)
         if not isinstance(device, PWMOut):
             device = PWMOut(self._seesaw, terminal)
             device.frequency = 1000
@@ -274,25 +298,25 @@ def _drive(self, terminal):
     @property
     def touch_1(self):
         """``adafruit_crickit.CrickitTouchIn`` object on Touch 1 terminal"""
-        return _touch(_TOUCH1)
+        return self._touch(_TOUCH1)
 
     @property
     def touch_2(self):
         """``adafruit_crickit.CrickitTouchIn`` object on Touch 2 terminal"""
-        return _touch(_TOUCH2)
+        return self._touch(_TOUCH2)
 
     @property
     def touch_3(self):
         """``adafruit_crickit.CrickitTouchIn`` object on Touch 3 terminal"""
-        return _touch(_TOUCH3)
+        return self._touch(_TOUCH3)
 
     @property
     def touch_4(self):
         """``adafruit_crickit.CrickitTouchIn`` object on Touch 4 terminal"""
-        return _touch(_TOUCH4)
+        return self._touch(_TOUCH4)
 
     def _touch(self, terminal):
-        touch_in = self._devices.get(terminals, None)
+        touch_in = self._devices.get(terminal, None)
         if not touch_in:
             touch_in = CrickitTouchIn(self._seesaw, terminal)
             self._devices[terminal] = touch_in
@@ -301,7 +325,7 @@ def _touch(self, terminal):
     @property
     def neopixel(self):
         """```adafruit_seesaw.neopixel`` object on NeoPixel terminal.
-        Raises ValueError if `init_neopixel` has not been called.
+        Raises ValueError if ``init_neopixel`` has not been called.
         """
         if not self._neopixel:
             raise ValueError("Call init_neopixel first")

docs/api.rst

@@ -4,8 +4,5 @@
 .. If your library file(s) are nested in a directory (e.g. /adafruit_foo/foo.py)
 .. use this format as the module name: "adafruit_foo.foo"
 
-.. automodule:: adafruit_crickit.terminals
-   :members:
-
-.. automodule:: adafruit_crickit.crickit
+.. automodule:: adafruit_crickit
    :members:

docs/conf.py

@@ -27,7 +27,7 @@
                        'CircuitPython': ('https://circuitpython.readthedocs.io/en/latest/', None)}
 
 # Libraries we depend on but don't need for generating docs.
-autodoc_mock_imports = []
+autodoc_mock_imports = ['board', 'busio', 'micropython', 'adafruit_seesaw', 'adafruit_motor']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']