Metadata-Version: 1.1
Name: pyA20
Version: 0.2.11
Summary: Control GPIO, I2C and SPI on A20-OLinuXino-MICRO
Home-page: https://www.olimex.com/
Author: Stefan Mavrodiev
Author-email: stefan@olimex.com
License: GPLv3
Description: pyA20
        =====
        
        |Build Status|
        
        Description
        -----------
        
        The package provide methods for controlling GPIO pins, I2C and SPI
        buses. It's written for
        `A20-OLinuXino-MICRO <https://www.olimex.com/Products/OLinuXino/A20/A20-OLinuXino-MICRO/open-source-hardware>`__,
        but it can be used with other boards. In this case proper operation is
        not guaranteed. You can check
        `wiki <https://www.olimex.com/wiki/A20-OLinuXino-MICRO>`__ for more
        information.
        
        **Notes**:
        
        	* When using GPIO make sure that the desired gpio is not used by another periphery.
        	* Using this library requires root access.
        
        GPIO methods
        ------------
        
        The following methods are available:
        
        * **init()** - Make initialization of the module. 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:
        
        * **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:
        
        .. code:: python
        
        	>>> from pyA20.gpio import port
        	>>> dir(port)
        
        * By connector name and pin number: gpio2p12, gpio3p8, lcdp18, uext1p3 and etc:
        
        .. code:: python
        
        	>>> from pyA20.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.
        
        .. code:: python
        
        	>>> 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
        ~~~~
        
        The example consist of: \* Initialize gpio module \* Initialize one gpio
        as output and another one as input \* Polling input state and write
        corresponding output value
        
        .. code:: python
        
        	#!/usr/bin/env python
        
        	from pyA20.gpio import gpio
        	from pyA20.gpio import port
        	from pyA20.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
        ~~~
        
        In this example: \* I2C module is imported \* Bus number 2 is opened \*
        Some data is written, then verified
        
        .. code:: python
        
        	#!/usr/bin/env python
        
        	from pyA20 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
        ~~~
        
        In ths example: \* SPI module is imported \* Bus 2 with chip-select 0 is
        opened \* Some data is transfered to slave device
        
        .. code:: python
        
        	#!/usr/bin/env python
        
        	from pyA20 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
        
        Changelog
        ---------
        
        -  pyA20 0.2.11 (21 NOV 2017)
        
        	- Fixed mapping on portG
        	-  Updated README
        	-  Removed processor checking to allow build scripts
        	-  Update license
        
        -  pyA20 0.2.0 (02 SEP 2014)
        
        	-  Updated to enable SPI and I2C control
        	-  GPIO constant in separate modules
        	-  Added example files
        	-  Added support for Python3
        
        .. |Build Status| image:: https://travis-ci.org/StefanMavrodiev/pyA20.svg?branch=master
           :target: https://travis-ci.org/StefanMavrodiev/pyA20
        
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python
Classifier: Topic :: Home Automation
Classifier: Topic :: Software Development :: Embedded Systems
