Metadata-Version: 1.1
Name: RPistepper
Version: 0.2a0
Summary: RPistepper is a library control stepper motors using a Raspberry Pi and a transistor array
Home-page: https://github.com/ArmlessJohn404/RPistepper
Author: Luiz Eduardo Nishino Gomes do Amaral
Author-email: luizamaral306@gmail.com
License: GPL3
Description: RPistepper
        ==========
        
        RPistepper is a library containing:
         - A class to control a stepper motor with a RPi.
         - A function to execute a zig-zag motion with two motors.
         -  A function to execute a square\_spiral motion with two motors.
        
        Wiring
        ------
        
        In our setup, the power to the motors (Vm) is supplied with the 5V pins
        of the RPi, the grounding of the coils is controlled with a
        `ULN2803A <http://www.ti.com/lit/ds/symlink/uln2803a.pdf>`__ transistor
        array.
        
        .. figure:: https://github.com/ArmlessJohn404/RPistepper/blob/master/pinout.png?raw=true
           :alt: Example setup
        
        Conections RPi - ULN2803A:
        ^^^^^^^^^^^^^^^^^^^^^^^^^^
        
        +-----------------+------------+
        | RPi Pin (BCM)   | ULN2803A   |
        +=================+============+
        | 17              | 1B         |
        +-----------------+------------+
        | 27              | 2B         |
        +-----------------+------------+
        | 10              | 3B         |
        +-----------------+------------+
        | 9               | 4B         |
        +-----------------+------------+
        | 14              | 5B         |
        +-----------------+------------+
        | 15              | 6B         |
        +-----------------+------------+
        | 23              | 7B         |
        +-----------------+------------+
        | 24              | 8B         |
        +-----------------+------------+
        
        Conections ULN2803A - Motors:
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        
        +------------+---------------------+
        | ULN2803A   | Motors              |
        +============+=====================+
        | 1C         | Motor\_1 Coil\_A1   |
        +------------+---------------------+
        | 2C         | Motor\_1 Coil\_A2   |
        +------------+---------------------+
        | 3C         | Motor\_1 Coil\_B1   |
        +------------+---------------------+
        | 4C         | Motor\_1 Coil\_B2   |
        +------------+---------------------+
        | 5C         | Motor\_2 Coil\_A1   |
        +------------+---------------------+
        | 6C         | Motor\_2 Coil\_A2   |
        +------------+---------------------+
        | 7C         | Motor\_2 Coil\_B1   |
        +------------+---------------------+
        | 8C         | Motor\_2 Coil\_B2   |
        +------------+---------------------+
        
        In this case, two motors were attached to the ULN2803A.
        
        Usage
        -----
        
        class RPiStepper
        ^^^^^^^^^^^^^^^^
        
        This class allows the user to control a 6 pin stepper motor using 4 GPIO
        pins of a RPi.
        
        Software uses BCM mode for pin indexing.
        
        This class is best used with the 'with' statement to properly handle the
        cleanup of the GPIOs.
        
        self.steps is a property of this class that will get the number of steps
        taken from the initial position or set to a specific step, similar to
        self.move.
        
        In order to save power, it's advised to call self.release() when the
        motor is idle.
        
        Arguments are a list with the 4 pins (Coil\_A1, Coil\_A2, Coil\_B1,
        Coil\_B2), the delay between steps (default = 20ms) and verbose to
        display reports on the motor movements, the last two are optional. e.g:
        
        .. code:: python
        
            import RPistepper as stp
            M1_pins = [17, 27, 10, 9]
            with stp.RPiStepper(M1_pins) as M1:
                for i in range(10):               # moves 20 steps,release and wait
                    print M1
                    M1.move(20)
                    M1.release()
                    raw_input('enter to execute next step')
        
        If the class is instantiated normally, use the method ``cleanup`` prior
        to closing the application to close the GPIO resources. Also, if it's
        important to go back to the initial position when finishing the routine,
        use the method ``reset``.
        
        .. code:: python
        
            import RPistepper as stp
            M1_pins = [17, 27, 10, 9]
            M1 = stp.RPiStepper(M1_pins)
            for i in range(10):               # moves 20 steps,release and wait
                print M1
                M1.move(20)
                M1.release()
                raw_input('enter to execute next step')
            M1.reset()
            M1.cleanup()
        
        Methods
        ^^^^^^^
        
        Currently there are four implemented methods:
        
        .. code:: python
        
            def move(self, steps):
                '''
                Moves the motor 'steps' steps. Negative steps moves the motor backwards
                '''
        
        .. code:: python
        
            def release(self):
                '''
                Sets all pins low. Power saving mode
                '''
        
        .. code:: python
        
            def reset(self):
                '''
                Returns the motor to it's initial position
                '''
        
        .. code:: python
        
            def cleanup(self):
                '''
                Cleans the GPIO resources
                '''
        
        The main method is ``move``, which moves the motor the desired number of
        steps
        
        steps property
        ^^^^^^^^^^^^^^
        
        It's possible to check the motor position or manually set the desired
        step using the ``steps`` property:
        
        .. code:: python
        
            import RPistepper as stp
            M1_pins = [17, 27, 10, 9]
            with stp.RPiStepper(M1_pins) as M1:
                for i in range(10):               # moves 20 steps,release and wait
                    print M1.steps
                    M1.steps = 20*i
                    M1.release()
                    raw_input('enter to execute next step')
                M1.reset()
        
        Attributes
        ^^^^^^^^^^
        
        This class haves the following attributes:
        
        +-----------------+------------------------------------------------+
        | Attribute       | Data                                           |
        +=================+================================================+
        | DELAY           | Time between steps                             |
        +-----------------+------------------------------------------------+
        | VERBOSE         | Display motor data on screen                   |
        +-----------------+------------------------------------------------+
        | PINS            | GPIOs used by the instance                     |
        +-----------------+------------------------------------------------+
        | actual\_state   | A list with the status of the coils (on/off)   |
        +-----------------+------------------------------------------------+
        
        functions
        ~~~~~~~~~
        
        These two functions executes pre determined movements and requires two
        stepper motor objects:
        
        .. code:: python
        
            def zig_zag(motor1, motor2, amp1, amp2, delay=None):
                '''
                Executes a zig-zag movement with two RPistepper objects.
                Arguments are: motor1 and motor2 objects and amp1, amp2, the amplitude
                of movement, a tuple (step, rep) representing the number of steps per
                iteration and the number of iterations of the following algorithm:
                    Repeat rep1 times:
                        1. Moves motor 2 step2*rep2 steps forward
                        2. Moves motor 1 step1 steps forward
                        3. Moves motor 2 step2*rep2 steps backwards
                        4. Moves motor 1 step1 steps forward
                    Reset to initial state
                    Release the motors
                It's possible to change the delay between steps with the 'delay' argument
                '''
        
        .. code:: python
        
            def square_spiral(motor1, motor2, amplitude, delay=None):
                '''
                Executes a square spiral movement with two RPistepper objects.
                Arguments are: motor1 and motor2 objects and the amplitude of movement,
                a tuple (step, rep) representing the number of steps per iteration and
                the number of iterations of the following algorithm:
                    for i in range(rep):
                        1. Moves motor 2 to position i
                        2. Moves motor 1 to position i
                        3. Moves motor 1 to position -i
                        4. Moves motor 2 to position -i
                    Reset to initial state
                    Release the motors
                It's possible to change the delay between steps with the 'delay' argument
                '''
        
Keywords: RPi ULN2803A stepper motor
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Topic :: System :: Hardware
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
