Raspberry pi python and gpio

raspberry-gpio-python Wiki

A Python module to control the GPIO on a Raspberry Pi

BasicUsage

RPi.GPIO module basics

Importing the module

To import the RPi.GPIO module:

By doing it this way, you can refer to it as just GPIO through the rest of your script.

To import the module and check to see if it is successful:

try: import RPi.GPIO as GPIO except RuntimeError: print("Error importing RPi.GPIO! This is probably because you need superuser privileges. You can achieve this by using 'sudo' to run your script") 

Pin numbering

There are two ways of numbering the IO pins on a Raspberry Pi within RPi.GPIO. The first is using the BOARD numbering system. This refers to the pin numbers on the P1 header of the Raspberry Pi board. The advantage of using this numbering system is that your hardware will always work, regardless of the board revision of the RPi. You will not need to rewire your connector or change your code.

The second numbering system is the BCM numbers. This is a lower level way of working — it refers to the channel numbers on the Broadcom SOC. You have to always work with a diagram of which channel number goes to which pin on the RPi board. Your script could break between revisions of Raspberry Pi boards.

To specify which you are using using (mandatory):

GPIO.setmode(GPIO.BOARD) # or GPIO.setmode(GPIO.BCM) 

To detect which pin numbering system has been set (for example, by another Python module):

The mode will be GPIO.BOARD, GPIO.BCM or None

Warnings

It is possible that you have more than one script/circuit on the GPIO of your Raspberry Pi. As a result of this, if RPi.GPIO detects that a pin has been configured to something other than the default (input), you get a warning when you try to configure a script. To disable these warnings:

Setup up a channel

You need to set up every channel you are using as an input or an output. To configure a channel as an input:

(where channel is the channel number based on the numbering system you have specified (BOARD or BCM)).

More advanced information about setting up input channels can be found here.

To set up a channel as an output:

(where channel is the channel number based on the numbering system you have specified (BOARD or BCM)).

You can also specify an initial value for your output channel:

GPIO.setup(channel, GPIO.OUT, initial=GPIO.HIGH) 

Setup more than one channel

You can set up more than one channel per call (release 0.5.8 onwards). For example:

chan_list = [11,12] # add as many channels as you want! # you can tuples instead i.e.: # chan_list = (11,12) GPIO.setup(chan_list, GPIO.OUT) 

Input

To read the value of a GPIO pin:

(where channel is the channel number based on the numbering system you have specified (BOARD or BCM)). This will return either 0 / GPIO.LOW / False or 1 / GPIO.HIGH / True.

Output

To set the output state of a GPIO pin:

(where channel is the channel number based on the numbering system you have specified (BOARD or BCM)).

State can be 0 / GPIO.LOW / False or 1 / GPIO.HIGH / True.

Output to several channels

You can output to many channels in the same call (release 0.5.8 onwards). For example:

chan_list = [11,12] # also works with tuples GPIO.output(chan_list, GPIO.LOW) # sets all to GPIO.LOW GPIO.output(chan_list, (GPIO.HIGH, GPIO.LOW)) # sets first HIGH and second LOW 

Cleanup

At the end any program, it is good practice to clean up any resources you might have used. This is no different with RPi.GPIO. By returning all channels you have used back to inputs with no pull up/down, you can avoid accidental damage to your RPi by shorting out the pins. Note that this will only clean up GPIO channels that your script has used. Note that GPIO.cleanup() also clears the pin numbering system in use.

To clean up at the end of your script:

It is possible that don’t want to clean up every channel leaving some set up when your program exits. You can clean up individual channels, a list or a tuple of channels:

GPIO.cleanup(channel) GPIO.cleanup( (channel1, channel2) ) GPIO.cleanup( [channel1, channel2] ) 

RPi Board Information and RPi.GPIO version

To discover information about your RPi:

To discover the Raspberry Pi board revision:

GPIO.RPI_INFO['P1_REVISION'] GPIO.RPI_REVISION (deprecated)

To discover the version of RPi.GPIO:

Источник

Использование GPIO из Python на Raspberry Pi

Делюсь своим опытом, полученным при изучении задачи вынесенной в заголовок. В статье рассматриваются два варианта работы, которые можно использовать в Python-программах, обращающихся к портами GPIO Raspberry Pi.

Порты GPIO Raspberry Pi выглядят следующим образом:

Одним из вариантов работы с GPIO является интерфейс Sysfs. Подробнее о Sysfs интерфейсе GPIO здесь. В этом случае для обращения к портам GPIO используются операции чтения и записи файлов. Для использования конкретного вывода его нужно зарезервировать и установить направление на вход или на выход. После окончания работы с портом его нужно освободить, чтобы другие процессы могли его использовать.

Резервирование порта (XX — номер нужного порта):

$ echo XX > /sys/class/gpio/export 

При успешном резервировании появляется новая папка по адресу /sys/class/gpio/gpioXX/ . Установка направления выполняется так:

$ echo "out" > /sys/class/gpio/gpioXX/direction 

$ echo "in" > /sys/class/gpio/gpioXX/direction 

Установка высокого и низкого уровней для порта, настроенного на выход выполняется так:

$ echo 1 > /sys/class/gpio/gpioXX/value $ echo 0 > /sys/class/gpio/gpioXX/value 

Определение состояние порта, настроенного на вход делается так:

$ cat /sys/class/gpio/gpioXX/value 

Освобождение порта после окончания его использования:

$ echo XX > /sys/class/gpio/unexport 

Для упрощения работы с GPIO через интерфейс Sysfs мне встретились две утилиты. Одна из них WiringPi GPIO utility, другая quick2wire-gpio-admin.

Основная задача, решаемая этими утилитами — это предоставление возможности работы с GPIO от имени непривилегированного пользователя. При этом WiringPi GPIO utility более функциональна.

Я для работы с GPIO остановился на пакете RPIO (на момент написания последней была версия 0.10.0). Этот пакет работает с портами GPIO напрямую, обращаясь к регистрам BCM2708 через специальное устройство /dev/mem . Что такое RPIO:

Advanced GPIO for the Raspberry Pi. Extends RPi.GPIO with PWM, GPIO interrups, TCP socket interrupts, command line tools and more

RPIO позиционируется как улучшенный и расширенный вариант другого модуля, RPi.GPIO. В документации непосредственно на RPIO подробно рассмотрены только возможности, отсутствующие в RPi.GPIO, по этому за описанием общих для этих модулей функций нужно обращаться к документации RPi.GPIO, доступной здесь.

Устанавливается пакет следующей командой:

Кроме python-модулей устанавливаюся две программы: rpio-curses и rpio. С их помощью можно, например, получить текущий режим и состояние GPIO и, при желании, изменить их. Так выглядит работа с rpio-curses:

Так можно получить информацию о системе:

$ rpio --sysinfo 000f: Model B, Revision 2.0, RAM: 512 MB, Maker: Qisda 

Пример python-программы, использующей RPIO:

import RPIO import time NRF_CE = 24 # set up output channel with an initial state RPIO.setup(NRF_CE, RPIO.OUT, initial=RPIO.LOW) for i in range(10): RPIO.output(NRF_CE, 1) time.sleep(1) RPIO.output(NRF_CE, 0) time.sleep(1) # reset every channel that has been set up by this program, # and unexport interrupt gpio interfaces RPIO.cleanup() 

Источник

Raspberry Pi: установка библиотеки RPi.GPIO для python

Одно из главных преимуществ Raspberry Pi — это наличие выводов общего назначения (General Purpose Iinput/Outputs). GPIO — это группа контактов, которыми можно управлять с помощью программы. Причем управление это может быть совсем простым, например, включение/выключение светодиода. Либо весьма сложным — обмен данными с периферийными устройствами по специализированным протоколам.

С помощью GPIO можно собирать данные с разных датчиков, управлять реле, двигателями, силовыми ключами. В общем, управлять реальным миром по составленной нами программе.

В этой статье я расскажу как установить на Raspberry Pi библиотеку управления GPIO для python — RPi.GPIO, и приведу несколько простых примеров работы с ней.

1. Загрузка и подготовка библиотеки RPi.GPIO

Первое что мы сделаем — скачаем архив с библиотекой с официального сайта:

Ссылка ведет на страницу с разными версиями библиотеки. Выбираем самый свежий архив. На момент написания статьи это был — RPi.GPIO-0.6.3.tar.gz

По-умолчанию, штатный браузер Chromium скачает библиотеку в папку /home/pi/Downloads. Зайдем в эту папку с помощью проводника:

Теперь жмем правую кнопку мыши на архиве и выбираем пункт Extract Here.

Этим самым мы просим разархивировать библиотеку в ту же папку, в которой находится сам архив. В результате рядом с архивом появится папка RPi.GPIO-0.6.3.

2. Установка дополнительного пакета для python

Перед тем, как установить библиотеку RPi.GPIO, нам потребуется дополнительный пакет python-dev. Для этого запустим терминал (черная иконка на верхней панели рабочего стола) и запустим в нем следующую команду:

sudo apt-get install python-dev

На вопрос «Do you want to continue? [Y/n]» пишем символ «Y» и жмем Enter.

В результате появится отчет об успешной установке. Выглядит он так:

3. Установка библиотеки RPi.GPIO

Теперь приступим к установке самой библиотеки для работы с GPIO. Не выходя из терминала, переходим в разархивированную ранее папку:

cd /home/pi/Downloads/RPi.GPIO-0.6.3

И запускаем команду для сборки библиотеки из исходных кодов:

В результате получим примерно такой отчет:

Далее запускаем команду установки библиотеки. Нужно выполнить её с правами администратора, поэтому вначале добавляем директиву sudo:

sudo python setup.py install

Ну вот и готово! Приступим к сборке стенда и составлению первой программы, которая будет управлять состоянием светодиода.

4. Подключение светодиода к Raspberry Pi

Разъем GPIO у Raspberry Pi имеет два типа нумерации. Первый тип — это последовательный номер контакта. Второй тип — BCM, соответствует выводам микропроцессора. Оба эти нумерации представлены на картинке.

В большинстве примеров используется тип нумерации BCM, последуем традиции. Подключаем светодиод к выводу GPIO23 по следующей схеме.

Анод светодиода (длинная ножка) соединим с выводом GPIO23 через резистор 200 Ом, а катод с землей (GND). Хорошо бы сначала вспомнить урок про макетные платы.

Теперь перейдем к написанию программы.

5. Программа для управления с помощью RPi.GPIO

В Raspbian установлены две версии python: 2 и 3. Поскольку мы установили библиотеку только для python 2, будет пользоваться именно это версией.

Открываем среду разработки Python 2 (IDLE). В меню появившегося окна выбираем New File.

Откроется окно редактора. В этом окне записываем программу, которая включит светодиод на 5 секунд, а затем погасит его.

from RPi import GPIO from time import sleep GPIO.setmode(GPIO.BCM) GPIO.setup(23, GPIO.OUT) GPIO.output(23, True) sleep(5) GPIO.output(23, False) GPIO.cleanup()

Программу желательно сохранить, например, в домашнюю папку. Делается это с помощью пункта меню File/Save As…

Наконец, запускаем программу через меню Run/Run Module или с помощью клавиши F5.

Заключение

Этот пример показывает, как легко управлять простыми исполнительными устройствами с помощью библиотеки RPi.GPIO. Вместо светодиода можно поставить, например, мощное реле и управлять включением уличного освещения, или, скажем, чайником. Однако, следует помнить, что функционал этой библиотеки весьма ограничен и для управления устройствами через интерфейсы I2C и SPI потребуются дополнительные специализированные библиотеки.

Источник