Metadata-Version: 1.1
Name: pyA13
Version: 0.2.1
Summary: Control GPIO, I2C and SPI
Home-page: https://www.olimex.com/
Author: Stefan Mavrodiev
Author-email: support@olimex.com
License: MIT
Description: This package provide methods for controlling GPIO pins, I2C and SPI buses.
        This is written for A13, but it can be used with other boards. If you do
        this we cannot guarantee proper operation of the module. Before using this
        package we recommend reading the article at olimex wiki:
        
        https://www.olimex.com/wiki/A13-OLinuXino
        
        When using GPIO make sure that the desired gpio is not used by another periphery.
        
        GPIO METHODS
        ============
        
            init()      -   Make initialization of the module. Always must be called first.
            getcfg()    -   Read current configuration of gpio.
            setcfg()    -   Write configuration to gpio.
            input()     -   Return current value of gpio.
            output()    -   Set output value.
            pullup()    -   Set pull-up/pull-down.
        
        
        The available constants are:
        
            NAME:       ->   EQUALS TO:
            HIGH        ->      1
            LOW         ->      0
            INPUT       ->      0
            OUPTUT      ->      1
            PULLUP      ->      1
            PULLDOWN    ->      2
        
        
        The gpio are named two ways:
        
            By port name: PH0, PG2, PE10, etc.
            These can be imported from port module:
        
            >>> from pyA13.gpio import port
            >>> dir(port)
        
            By connector name and pin number: gpio2p12, gpio3p8, etc.
            These can be imported from connector module:
        
            >>> from pyA13.gpio import connector
            >>> dir(connector)
        
        Generally these constants are just an offset in the memory from the base GPIO address, so they can
        be assigned to a number type variable.
        
            >>> led = port.PH2
            >>> print led
            226
        
        
        
        I2C METHODS
        ===========
        
            init()      -   Make initialization of the module
            open()      -   Begin communication with slave device
            read()      -   Read from slave device
            write()     -   Write data to slave device
            close()     -   End communication with slave device
        
        
        SPI METHODS
        ===========
        
            open()      -   Open SPI bus with given configuration
            read()      -   Read data from slave device without write
            write()     -   Write data to slave device without read
            xfer()      -   Do write and after that read
            close()     -   Close SPI bus
        
        
        
        Examples
        ========
        
        GPIO::
        
            #!/usr/bin/env python
        
            from pyA13.gpio import gpio
            from pyA13.gpio import port
            from pyA13.gpio import connector
        
            gpio.init() #Initialize module. Always called first
        
            gpio.setcfg(port.PG9, gpio.OUTPUT)  #Configure LED1 as output
            gpio.setcfg(port.PG9, 1)    #This is the same as above
        
            gpio.setcfg(port.PE11, gpio.INPUT)   #Configure PE11 as input
            gpio.setcfg(port.PE11, 0)   #Same as above
        
            gpio.pullup(port.PE11, 0)   #Clear pullups
            gpio.pullup(port.PE11, gpio.PULLDOWN)    #Enable pull-down
            gpio.pullup(port.PE11, gpio.PULLUP)  #Enable pull-up
        
            while True:
                if gpio.input(port.PE11) == 1:
                    gpio.output(port.PG9, gpio.LOW)
                    gpio.output(port.PG9, 0)
                else:
                    gpio.output(port.PG9, gpio.HIGH)
                    gpio.output(port.PG9, 1)
        
        
        I2C::
        
            #!/usr/bin/env python
        
            from pyA13 import i2c
        
            i2c.init("/dev/i2c-2")  #Initialize module to use /dev/i2c-2
            i2c.open(0x55)  #The slave device address is 0x55
        
            #If we want to write to some register
            i2c.write([0xAA, 0x20]) #Write 0x20 to register 0xAA
            i2c.write([0xAA, 0x10, 0x11, 0x12]) #Do continuous write with start address 0xAA
        
            #If we want to do write and read
            i2c.write([0xAA])   #Set address at 0xAA register
            value = i2c.read(1) #Read 1 byte with start address 0xAA
        
            i2c.close() #End communication with slave device
        
        
        SPI::
        
            #!/usr/bin/env python
        
            from pyA13 import spi
        
            spi.open("/dev/spidev2.0")
            #Open SPI device with default settings
            # mode : 0
            # speed : 100000kHz
            # delay : 0
            # bits-per-word: 8
        
            #Different ways to open device
            spi.open("/dev/spidev2.0", mode=1)
            spi.open("/dev/spidev2.0", mode=2, delay=0)
            spi.open("/dev/spidev2.0", mode=3, delay=0, bits_per_word=8)
            spi.open("/dev/spidev2.0", mode=0, delay=0, bits_per_word=8, speed=100000)
        
            spi.write([0x01, 0x02]) #Write 2 bytes to slave device
            spi.read(2) #Read 2 bytes from slave device
            spi.xfer([0x01, 0x02], 2)   #Write 2 byte and then read 2 bytes.
        
            spi.close() #Close SPI bus
        
        
        It's important that you run your python script as root!
            
        
            
        Changelog
        =========
            * pyA13 0.2.1 (16 OCT 2014)
        	* Fixed some typos
        
            * pyA13 0.2.0 (03 SEP 2014)
                * Updated to enable SPI and I2C control
                * GPIO constant in separate modules
                * Added example files
                * Added support for Python3
        
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python
Classifier: Topic :: Home Automation
Classifier: Topic :: Software Development :: Embedded Systems
