Использование gpio выводов raspberry pi

Использование портов GPIO в Raspberry Pi. Часть 1

В этой статье рассказано о том, как устроены универсальные порты ввода-вывода (GPIO) и о том, как работать с ними на перле.

Одноплатный компьютер Raspberry Pi примечателен не только своими размером и ценой, но и наличием порта ввода-вывода общего назначения (General Purpose Input-Output, GPIO). Эдакая современная версия параллельного LPT-порта, которая вместе с компьютером занимает меньше места, чем плата PCI с контроллером LPT.

Базовая информация о портах

В базовом комплекте второй версии Raspberry Pi установлен один 26-контактный разьем (он обозначен на плате как P1), в котором доступно 17 портов ввода-вывода (тех самых GPIO). Остальные восемь контактов подключены к земле или к питанию +3,3 В и +5 В. Выводы, отданные под GPIO, могут быть программно переконфигурированы для работы в качестве последовательных портов, вывода с широтно-импульсной модуляцией и еще как-то (вот это все называется альтернативными режимами). Но по умолчанию после включения питания все контакты работают в режиме «один контакт — один бит». Каждый из них может быть либо входом, либо выходом (по умолчанию включен режим ввода).

Кроме упомянутого разъема P1 на плате есть отверстия для установки восьмиконтактного разъема P5, который дает возможность получить еще четыре порта GPIO. Итого в распоряжении программиста оказывается 21 бинарный порт.

Наличие GPIO позволяет относительно легко связывать компьютер с устройствами из реального мира и управлять ими программно. Разумеется, здесь потребуется знание не только программирования, но и хотя бы основ электроники (детям рекоменую книгу В. Т. Полякова «Посвящение в радиоэлектронику», взрослым — книгу П. Хоровица и У. Хилла «Искусство схемотехники»).

При работе с GPIO важно учитывать пару моментов:

  1. Рабочее напряжение всех выводов — 3,3 В. Случайная подача на вход GPIO большего напряжения (даже 5 В с соседнего штырька разъема) приводит к выходу из строя не только этого вывода, но и вообще всего Raspberry Pi (подтверждаю экспериментально).
  2. Контакты разъема P1 и нумерация портов GPIO не совпадает, поэтому при программировании надо всегда помнить, какая из нумераций используется. Еще более они не совпадают в первой версии Raspberry (надеюсь, сейчас, если не прилагать дополнительных усилий, купить удастся только новую модель).
  3. Дополнительным пунктом надо отметить, что нумерация самих GPIO в Raspberry Pi идет с пропусками.
  4. Raspberry Pi построен на ARM-процессоре BCM2835, поэтому иногда полезнее гуглить BCM2835, а не Raspberry GPIO (то же самое действительно для поиска на CPAN).

Хорошее практическое описание опубликовано на странице elinux.org/RPi_Low-level_peripherals.

Для справки, вот так разведены порты GPIO на контакты разъемов P1 и P5 (контакты традиционно обозначаются в формате PX-NN, где X — номер раъема, а NN — двузначный номер контакта):

  1. GPIO02 — P1-03
  2. GPIO03 — P1-05
  3. GPIO04 — P1-07
  4. GPIO07 — P1-26
  5. GPIO08 — P1-24
  6. GPIO09 — P1-21
  7. GPIO10 — P1-19
  8. GPIO11 — P1-23
  9. GPIO14 — P1-08
  10. GPIO15 — P1-10
  11. GPIO17 — P1-11
  12. GPIO18 — P1-12
  13. GPIO22 — P1-15
  14. GPIO23 — P1-16
  15. GPIO24 — P1-18
  16. GPIO25 — P1-22
  17. GPIO27 — P1-13
  18. GPIO28 — P5-03
  19. GPIO29 — P5-04
  20. GPIO30 — P5-05
  21. GPIO31 — P5-06

Каждый битовый порт способен работать в режиме ввода или вывода. Кроме того, в режиме ввода может быть дополнительно включен подтягивающий резистор, что поможет максимально упростить способ подключения выключателей — их достаточно подключить между соответствующим выводом GPIO и общим проводом (если включен резистор pull up) или между GPIO и источником питания +3,3 В (если выход сконфигурирован в режиме pull down).

За более детальными продробностями о внутреннем устройстве портов GPIO я отсылаю читателя к шестой главе «General Purpose I/O (GPIO)» мануала по процессору BCM2835.

Регистры для работы с GPIO

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

Процессор BCM2835 имеет 41 32-разрядный регистр, которые полностью определяют режим и состояние портов GPIO. В частности, для установки единичного значения на выводе, запрограммированном на работу как выход, необходимо записать единичный бит в соответствующий разряд одного из двух регистров установки битов GPIO Pin Output Set Registers (GPSETn). Чтобы установить выход в ноль, следует выставить единичный бит в регистрах сброса битов GPIO Pin Output Clear Registers (GPCLRn). Такая на первый взгляд странная схема позволяет независимо устанавливать и сбрасывать любой бит GPIO без необходимости чтения текущего состояния выводов.

Аналогично, когда разряды GPIO работают на чтение, то узнать уровень входного сигнала можно, прочитав значение одного из двух портов GPIO Pin Level Registers (GPLEVn), каждый бит которого отображает текущее состояние входного разряда.

Программирование портов ввода-вывода

Регистры, отвечающие за работу с GPIO, расположены по адресам 0x7E200000—0x7E2000B0, которые отображаются на физическую память с адресами, начинающимися с 0x20200000. В принципе, в этом месте уже можно было бы начать управлять портами, программируя чтение и запись нужных битов в эти регистры (на перле это вполне возможно, если воспользоваться мапингом переменных на области памяти, используя модуль Sys::Mmap).

Но более практично еще немного усложнить систему, чтобы программировать стало легче.

Модуль Device::BCM2835

Для управления портами ввода-вывода на перле удобно воспользоваться модулем Device::BCM2835. Он является Perl-оберткой над C-библиотекой того же автора bcm2835 и один в один повторяет все ее функции (поэтому документацию может оказаться полезнее почитать в оригинале).

Установка библиотеки bcm2835 не вызывает сложностей:

Равно как и модуль со CPAN:

Библиотека (и модуль на перле) определяет огромное число констант, позволяющих выбирать нужные выводы разьъемов P1 и P5 и устанавливать режимы их работы, и довольно большое число функций для доступа к отдельным битам GPIO.

Все дальнейшие действия необходимо выполнять от имени суперпользователя.

Перед началом работы следует вызвать функцию init() :

(При инициализации происходит вызов функций mmap и создание переменных, которые отображаются на нужные регистры процессора — ровно то, где прикладному программисту проще воспользоваться готовой библиотекой.)

Вызов теоретически может завершиться неудачой, хотя наиболее вероятная причина отказа — запуск скрипта не от рута:

Примечание ко всем примерам кода из документации. Модуль Device::BCM2835 разрешает экспортировать используемые константы, но при этом не хочет экспортировать имена функций (несмотря на то, что многие из них начинаются с префикса gpio_ ). Поэтому если подключить модуль с экспортом констант, то бесконечные повторы получится значительно, но все же не полностью, сократить и вместо:

Вывод

Чтобы переключить один из разрядов порта GPIO для работы в режиме вывода, надо вызвать функцию установки режима gpio_fsel($pin, $mode) и передать ей номер вывода (константу, соответствующую номеру физического вывода нужного разъема) и режим (другую определенную константу). Например, чтобы перевести выход P1-12 в режим вывода, следует выполнить следующее:

Запись нуля или единицы выполняют, либо вызывая функцию gpio_write($pin, $value) :

Либо используя пару функций gpio_set($pin) и gpio_clr($pin) , которым достаточно передать номер вывода:

Обратите внимание, что в обоих примерах физический вывод P1-12 ( RPI_V2_GPIO_P1_12 ) является логическим выходом GPIO18. А еще обратите внимание на наличие V2 в именах констант. Для первой версии Raspberry Pi следует использовать константы типа RPI_GPIO_P1_12 , которые за парой исключений совпадают с вариантами с V2 . Но следует иметь в виду, что порт P5 доступен только во второй версии, например: RPI_V2_GPIO_P5_04 для GPIO29.

Чтение данных с портов ввода-вывода также прост, как и запись в них. Прежде всего, необходимо перевести соответствующие разряды GPIO в режим чтения (BCM2835_GPIO_FSEL_INPT):

По желанию и необходимости можно подключить один из подтягивающих резисторов:

В случае, если к выводу порта подключена кнопка, замыкающая вывод на землю, то будет полезен резистор, подключенный к источнику питания +3,3 В (BCM2835_GPIO_PUD_UP), что обеспечит на входе уровень логической единицы, когда кнопка не нажата. При нажатой кнопке на входе окажется логический нуль.

Чтобы прочитать значение со входа, достаточно вызвать функцию gpio_lev($pin) , передав ей номер нужного входа:

Функция возвращает либо нуль, либо единицу.

Примеры

Как видно из предыдущих разделов, работать с портами ввода-вывода в бинарном режиме очень просто. Для закрепления материала — два небольших примера, которые будет полезно выполнить, если вы соберетесь программировать порты GPIO.

Код из первого примера раз в секунду включает и выключает светодиод, подключенный (через резистор сопротивлением 300…1000 Ом) к выводу GPIO03 (контакт P1-05).

Обратите внимание на использование функции Device::BCM2835::delay($n) из того же модуля, которая выполняет задержку на $n миллисекунд. Доступна и функция Device::BCM8235::delayMicroseconds($n) для задержки в микросекундах. Обе, однако, не гарантируют точности отсчитанного времени. На практике следует быть осторожным, если требуется получить более или менее точные задержки меньше 20-50 миллисекунд.

Второй пример включает тот же светодиод при нажатии на кнопку, подключенную ко входу GPIO15 (P1-10).

Здесь интересно отметить, что в отличие от предыдущего примера удобнее воспользоваться функцией gpio_write , а не парой gpio_set и gpio_clr .

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

В этой статье описаны эксперименты с GPIO (General Purpose Input/Output, Входы/Выходы общего назначения) контактами Raspberry Pi. Я попробовал работать с ними тремя способами: Python, Bash и C. В этой статье будет описаны все три способа. Но для начала немного информации о настройке и подготовке.

Подключение к GPIO контактам RPi: Я использовал старый IDE шлейф от флоппи дисковода. Он имеет 34 контакта, а RPi имеет только 26 контактов, поэтому часть разъема не используется. На другом конце шлейфа припаяны BLS штырьки, которые вставлены в макетную плату и до сих пор очень хорошо работают.

Подключение выводов: По ссылкам есть таблица с значением выводов и схема их расположения. Выводы считаются слева на право, сверху вниз начиная с вывода 3.3В. Вот как использованы контакты у меня:
Вывод 2: 5В
Вывод 3: «GPIO0». К нему подключен один из выводов выключателя, другой его вывод подключен к GND. Этот вывод GPIO имеет внутренний подтягивающий pull-up резистор. Это означает, что когда переключатель не замкнут, на выходе высокий уровень, а когда замкнут – низкий.
Вывод 6: GND (этот вывод подключен к GND макетной платы)
Вывод 7: «GPIO4». К нему подключается анод светодиода через резистор 220 Ом.

Читайте также  Двойной изолированный вольтметр для латра на atmega8-arduino

Во всех следующих примерах будет использовано такое подключение. Различные библиотеки используют различные выводы, создавая путаницу, поэтому я постараюсь избавиться от неё. Также отметим, что всё это делается в режиме SSH, поэтому монитор не подключен.

Важное примечание: В RPi Wiki написано, что GPIO выводы небуферизованны и незащищены, поэтому короткое замыкание представляет опасность для всего RPi, поэтому будьте осторожны! Разрабатывается новая версия платы с защитой.

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

Python

Это один из моих любимых языков, поэтому я решил попробовать его. Во-первых, установите pip (Python package installer, пакет установки Python):

sudo curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | python

Затем установите RPi.GPIO модуль для Python:

sudo pip install rpi.gpio

Теперь вы можете войти в интерпретатор Python (sudo python), и делать такие вещи:

import RPi.GPIO as GPIO
GPIO.setup(7, GPIO.OUT)
GPIO.output(7, True)
GPIO.output(7,False)

Я всегда любил Unix за то, что основной его идеей является то, что все является файлом. GPIO контакты Raspberry Pi также являются файлами! С применением нашей макетной платы мы можем зажигать и гасить светодиод.

sudo su —
echo «4» > /sys/class/gpio/export
echo «4» > /sys/class/gpio/export
echo «out» > /sys/class/gpio/gpio4/direction
echo «1» > /sys/class/gpio/gpio4/value
echo «0» > /sys/class/gpio/gpio4/value

Для чтения входов используйте команду «cat» и путь файла.

echo «0» > /sys/class/gpio/export
echo «in» > /sys/class/gpio/gpio0/direction
cat /sys/class/gpio/gpio0/value

Старый добрый C. Базовый пример для C действительно сложный, но, к счастью Гордон написал Arduino подобную библиотеку, но для Raspberry Pi! Итак, вот что нужно сделать:

Загрузите и установите библиотеку:

cd /tmp
wget http://project-downloads.drogon.net/files/wiringPi-1.tgz
tar xfz wiringPi-1.tgz
cd wiringPi/wiringPi
make
sudo make install

В системе вашего Raspberry Pi теперь установлена библиотека wiringPi, поэтому мы можем написать небольшую программу с использованием её.

Скопируйте код данной программы:

gcc -o blink blink.c -L/usr/local/lib -lwiringPi

У вас должен получиться мигающий светодиод. Теперь можно сделать что-то более интересное:

А как же функция analogRead? К сожалению, в отличие от Arduino, RPi не имеет встроенного АЦП (аналого-цифрового преобразователя). Но некоторые из разрабатываемых плат будут включать в себя АЦП, например Gertboard

Digitrode

цифровая электроника вычислительная техника встраиваемые системы

  • Вычислительная техника
    • Микроконтроллеры микропроцессоры
    • ПЛИС
    • Мини-ПК
  • Силовая электроника
  • Датчики
  • Интерфейсы
  • Теория
    • Программирование
    • ТАУ и ЦОС
  • Перспективные технологии
    • 3D печать
    • Робототехника
    • Искусственный интеллект
    • Криптовалюты

Чтение RSS

Управление линиями GPIO на Raspberry Pi

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

GPIO находятся на разъеме 2×13, на котором можно найти интерфейсы SPI, I2C, UART и линии питания 3.3 В и 5 В.

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

Итак, как же управлять линиями GPIO на Raspberry Pi?

Для начала нужно установить библиотеку RPi.GPIO Python Library. Возможно, она уже была предустановленна на ваш дистрибутив операционной системы Raspbian OS. Чтобы проверить это, введите:

sudo python

Затем введите в строчке:

import RPi.GPIO as GPIO

Если не появилась ошибка, то все хорошо. Но если же она возникла, то нужно сделать следующие шаги.

Для начала загружаем RPi GPIO Library:

wget http://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.3.1a.tar.gz

Затем извлекаем файлы:

tar zxf RPi.GPIO-0.3.1a.tar.gz

Потом переходим в извлеченный каталог:

cd RPi.GPIO-0.3.1a

И устанавливаем библиотеку:

sudo python setup.py install

Использование библиотеки RPi.GPIO Python Library

Различие между GPIO.setmode(GPIO.BOARD) и GPIO.setmode(GPIO.BCM) заключается в системе нумерации выводов. В первом случае используется нумерация разъема P1 на борту Raspberry Pi, а во втором случае нумерация выводов системы-на-кристалле Broadcom, являющейся ядром Raspberry Pi. Следует знать, что в случае с BCM нумерация выводов между первой и второй ревизиями немного отличается, а при использовании BOARD ревизия не имеет никакого значения, все остается тем же самым.

Теперь подключим к Raspberry Pi светодиоды и кнопки. На разъеме нам доступны восемь GPIO.

Значения сопротивлений резисторов могут быть вычислены следующим образом. Используемые в данном случае 5-миллиметровые светодиоды потребляют ток 20 мА. Напряжение, подаваемое с Raspberry Pi, составляет 3.3 В. Тогда сопротивление будет равно 3.3 В / 20 мА = 165 Ом. Для кнопок были задействованы резисторы 1 КОм.

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

Raspberry Pi. Работа с портами ввода-вывода GPIO.

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

Все версии Raspberry Pi оснащены штыревым разъемом, на который выведены порты GPIO. Начиная с 2014-го года разъем стал 40-пиновым (ранее было 26). На версиях Pi Zero и Pi Zero W присутствует посадочное место для разъема, но физически он не распаян:

В любом случае, как и с любой другой платой, расположение сигналов на этом разъеме для конкретной модификации лучше всего проверить по официальному даташиту. Хотя на разных версиях плат 40-пиновые разъемы для совместимости идентичны. Распиновка и сам разъем выглядят следующим образом:

Порты можно разделить на несколько категорий:

Разберем по очереди… Пины 3.3V и 5V могут использоваться для питания внешних устройств, подключенных к плате. При этом ограничение по току выглядит так:

  • Максимальный ток для вывода 5V определяется по формуле:

где I_ <вх>– это входной ток источника, который мы используем для питания платы. А I_ <п>– это ток, потребляемый самой платой, а также внешними устройствами, подключенными по USB. То есть мы подаем входной ток, часть его потребляют узлы платы, а то, что остается мы можем использовать для дополнительных устройств, подключенных к пину 5V.

  • Для выводов 3.3V все проще – максимальный ток составляет 50 мА и на этом точка.

В итоге за вычетом выводов 3.3V, 5V и Ground остаются 28 пинов GPIO, помеченных на схеме зеленым. GPIO0 и GPIO1 можно считать зарезервированными (их назначение обязательно обсудим в отдельной статье). Таким образом, остается 26 выводов, которые можно использовать по-своему усмотрению. Каждый из них может быть сконфигурирован на работу в том или ином режиме. Вот, к примеру, возможные функции портов для платы Raspberry Pi 4:

То есть любой из портов ввода-вывода может выполнять до 6-ти различных функций, в зависимости от конфигурации. В частности, GPIO2 может быть использован как сигнал SDA для I2C1 (SDA1), либо, к примеру, как сигнал MOSI для интерфейса SPI3 (SPI3_MOSI).

Об I2C и SPI поговорим в ближайших статьях, а сегодня нас интересует использование GPIO в качестве “обычных” входов и выходов. В режиме выхода на пин может быть выведен высокий (3.3 В) или низкий (0 В) уровень напряжения. А, соответственно, в режиме входа мы можем проанализировать, какой уровень подан на пин – высокий или низкий – 3.3 В или 0 В. Тут важно обратить внимание, что порты не являются толерантными к 5 В, то есть подавать на вход 5 В категорически нельзя.

В режиме входа для любого из GPIO можно активировать внутреннюю подтяжку к питанию или земле (pull-up/pull-down). Если вывод настроен на использование подтяжки вверх, то это означает, что при отсутствии сигнала (ничего не подключено) со входа будет считываться высокий уровень. С pull-down ситуация обратная – на входе в данном случае будет низкий уровень.

Исключением являются пины GPIO2 и GPIO3. Они имеют фиксированную подтяжку вверх, без вариантов.

В режиме выхода мы снова возвращаемся к ключевому параметру, а именно к ограничению по току. Максимальный ток для одного вывода составляет 16 мА. При этом, если используются несколько выходов, то суммарный ток не должен превышать 50 мА. Превышение допустимых значений с большой вероятностью приведет к выгоранию порта.

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

Выберем GPIO3 для светодиода и GPIO4 для кнопки. Схема подключения будет такой:

Давайте в двух словах разберем, что, как и зачем подключено. Начнем с кнопки. Программно активируем для GPIO4 подтяжку вверх, поэтому если кнопка не нажата мы получим на входе высокий уровень (логическую единицу). Соответственно, для того, чтобы определить нажатие кнопки, подключим ее к земле. В итоге при нажатой кнопке на входе будет низкий уровень (логический ноль). Поскольку используем внутреннюю подтяжку, в этом примере ставить дополнительный внешний резистор подтяжки не будем.

Резистор R_ <1>– токоограничительный. Как вытекает из названия он нужен для ограничения тока Рассмотрим, что произойдет, если вывод GPIO4 будет ошибочно настроен не как вход, а как выход и на нем будет 3.3 В. При нажатии кнопки произойдет короткое замыкание 3.3 В на землю, что приведет к безвозвратному повреждению порта платы. Это в случае отсутствия резистора.

Читайте также  Сенсорные регуляторы яркости с фазоимпульсным и шим управлением

А при наличии резистора ток будет ограничен величиной:

В данном случае получаем 3.3 мА, что вполне допустимо, и позволит сохранить порту жизнь в случае возникновения замыкания.

Итак, переходим к диоду, который подключен через резистор R_ <2>. Каждому диоду соответствует своя собственная вольт-амперная характеристика (ВАХ), определяющая возможные значения прямого напряжения и тока. Рассмотрим первый попавшийся под руку светодиод, например такой – ссылка:

Открываем даташит на него и находим зависимость тока от напряжения при прямом включении:

Максимальный ток для GPIO в режиме выхода, как мы уже выяснили, составляет 16 мА. Чтобы не превысить это значение подадим на светодиод, например, 10 мА. Этому току, исходя из графика, соответствует напряжение 2 В. Теперь по закону Ома нам остается только определить величину резистора. На выходе GPIO у нас 3.3 В, на диоде должно падать 2 В, значит на резисторе остается:

При этом ток в цепи должен быть равен 10 мА, тогда сопротивление резистора:

Если точной величины под рукой нет, можно взять резистор номиналом чуть больше. В общем, суть тут одна – обеспечить режим работы, при котором ток через выход не превышает допустимые 16 мА. Для большинства светодиодов в документации просто приводятся конкретные типовые значения напряжения и тока, например 2.5 В и 15 мА. Расчет будет выглядеть точно так же, как и рассмотренный, просто значения другие.

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

И для работы с портами ввода-вывода используем библиотеку/модуль RPi.GPIO. В Raspberry Pi OS он включен по умолчанию, но в случае отсутствия команда для установки такая:

Создаем файл gpio_test.py и добавляем в него следующий код:

Пройдемся по коду подробнее, прямо по всем строкам последовательно. Делаем import модулей для работы с GPIO и для использования временной задержки:

Добавим переменные для хранения номеров портов и величины задержки. У нас светодиод на GPIO3, а кнопка на GPIO4. Так и определим:

Далее настроим режим нумерации портов, чтобы номера соответствовали названию сигнала (например, GPIO3), а не порядковому номеру на разъеме:

Настраиваем GPIO3 на работу в режиме выхода и гасим светодиод, подав низкий уровень:

GPIO4 – в режиме входа с подтяжкой вверх:

Далее организуем вечный цикл while True, в котором и будем проверять состояние кнопки и мигать светодиодом. Только обернем его в блок try, чтобы отловить исключение, возникающее, когда пользователь завершает процесс (нажав Ctrl + C). В случае завершения выполнения программы вызываем GPIO.cleanup():

Ну и, конечно, здесь же у нас вся полезная работа. Если кнопка нажата (а в нашей схеме этому соответствует низкий уровень/логический ноль на GPIO4), то зажигаем светодиод и выводим сообщение “led on“. При отпускании кнопки – обратный процесс. Проверять кнопку будем каждые 0.5 с (DELAY_TIME).

Запускаем программу командой:

И теперь, нажимая кнопку, можем наблюдать включение и выключение светодиода, как мы и планировали!

Работа через GPIO в Raspberry Pi 3

  • Что такое колодка GPIO
  • Устройство GPIO
  • Особенности GPIO «малинки»
  • Особые порты
  • Нумерация
  • Способы взаимодействия с интерфейсом GPIO
  • Управление на bash
  • Управление через Python
  • Пример работы
  • Заключение
  • Где купить
  • Видео по теме

Одна из основных функций одноплатных компьютеров семейства Raspberry Pi — обеспечивать взаимодействие с разнообразной периферией. Это могут быть датчики, реле и двигатели, лампочки и прочие исполнительные модули и блоки. За такое «общение» отвечает встроенный в платы Raspberry Pi GPIO — интерфейс ввода-вывода. Рассмотрим его подробнее на примере RPi 3 B.

Что такое колодка GPIO

GPIO — сокращение, означающая General-Purpose Input-Output, или общий интерфейс ввода/вывода. Он содержит цифровые входы и выходы для подключения датчиков, разнообразных контроллеров, дисплеев, реле и прочей электронной периферии. Внешне GPIO похож на «гребенку» из штырьков-пинов. В Raspberry Pi 3 его внешний вид таков (в верхней части платы):

Колодка GPIO Raspberry чем-то напоминает интерфейс подключения жестких дисков IDE.

Для правильной работы через GPIO необходимо знать конфигурацию пинов. В Raspberry Pi распиновка такова:

Разъемов питания 4. Прочие пины способны выступать в роли входа или выхода. Кроме того, некоторые из них многофункциональны и могут работать как интерфейс UART, I2C, SPI или ШИМ.

Рассмотрим более подробно устройство «гребенки».

Устройство GPIO

Число пинов на колодке GPIO Raspberry Pi 3 равняется 40. Они пронумерованы и делятся на три группы:

  • питающие (power на схемах);
  • заземляющие (GND, Ground);
  • порты (часто обозначаются как BCM).

Первые необходимы для подачи электричества разных напряжений — 3.3 и 5 В. Разница между ними была рассмотрена выше. Вторые обеспечивают безопасность работы платы, отводя электричество. А третьи выступают в качестве интерфейсов, принимая и отдавая данные. Именно к ним пользователь подключает свои модули и приборы.

Схема пинов Raspberry Pi 3 Model B:

На данной схеме pinout выводы пронумерованы по следующему принципу:

  • 1 — левый в первом верхнем ряду;
  • 2 — второй в верхнем ряду, и так далее.

Выходы 1 и 17 обеспечивают питание 3.3 В, 2 и 4 — для 5 В. «Земля» расположена на 9, 25 и 39, и на 6, 14, 20, 30, 34. Прочие контакты — интерфейсные порты.

Особенности GPIO «малинки»

При работе необходимо учитывать несколько важных моментов:

  • на обоих выводах 3.3 В суммарный ток равен 50 мА. Поэтому напрямую к ним можно подключать устройства с общим потреблением до 50 миллиампер;
  • 5-вольтовые выводы поддерживают в сумме до 500 мА, что позволяет подсоединять к ним более мощную периферию, включая устройства ввода (мышки, клавиатуры и так далее);
  • GPIO допускает подачу напряжения только до 3.3 В. Если превысить это значение, велик шанс сжечь вход или весь контроллер;
  • 14-15 пины по умолчанию работают как RXD и TXD UART-интерфейса и сразу после включения выдают напряжение в 3.3 В;
  • также по умолчанию почти все конфигурируемые выводы «малинки» являются входами с высоким сопротивлением. Исключение — GPIO0 и GPIO1 (SDA и SCL соответственно);
  • работая в режиме INPUT, пин автоматически переводит подаваемую на него информацию в цифровой вид. При этом отметим, что RPi3 исходно работает только с цифровым сигналом, а для обработки аналоговых используется специальный преобразователь ЦАП/АЦП.

Важно помнить: все «ножки» колодки соединены с процессором напрямую, некорректные операции и неверное подключение способно привести к полной неработоспособности платы.

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

Как правило, RPi3 работает под управлением ОС семейства Linux (Raspbian или другой). Сразу после загрузки системы напряжение на пинах низкое и остается таковым до изменения запустившимся скриптом или программой. Но в промежуток от подачи электропитания до инициализации системных драйверов пины в произвольном порядке способны выдавать высокое напряжение. Это следует учитывать и изолировать по питанию входы-выходы в процессе запуска системы.

Особые порты

Внешние модули можно подсоединять к любым портам «гребенки» GPIO. Но есть два особенных, которые плата резервирует для специфических задач. На обычной схеме их номера — 27 и 28. Они предназначены для плат расширения, и желательно не использовать их без необходимости.

Нумерация

Выше рассматривались номера пинов. Но важно понимать, что заложенная в центральный процессор логическая нумерация отличается от приведенной на схеме физической. Ее особенности:

  • не исполняющие функций ввода-вывода «штырьки» номеров не имеют;
  • контакт 3 является портом, но имеет логический номер BCM2.

Этот принцип следует учитывать при создании кода, поскольку ПО ориентируется именно на логические номера. Их схема:

У новичков это может вызвать недоумение и путаницу. Для помощи в решении проблемы существует программная библиотека Wiring Pi с собственной альтернативной нумерацией. Так, логический GPIO2 в ней определен как WIringPI 8. Это может показаться непонятным, но после освоения библиотеки ее принцип нумерования становится привычным и удобным.

Способы взаимодействия с интерфейсом GPIO

Интерфейсная гребенка позволяет работать с собой несколькими путями:

  • встроенными инструментами Linux (через интерпретатор bash и средства файловой системы);
  • посредством языков программирования.

Управление на bash

Если использовать Raspbian, «баш» доступен по умолчанию. Пример отправки логического «1» на пин номер 25:
sudo su —
echo 25 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio25/direction
echo 1 > /sys/class/gpio/gpio25/value
echo 0 > /sys/class/gpio/gpio25/value

Чтение данных со входа номер 24:

echo 24 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio24/direction
cat > /sys/class/gpio/gpio24/value

Управление через Python

Питон — один из самых популярных языков разработки под Raspberry, и в нем создан богатый инструментарий. В последних дистрибутивах ОС Raspbian уже присутствует и сама среда Python, и необходимая для работы библиотека RPi.GPIO. Если же таковой нет, ее можно загрузить из репозитория:

sudo apt-get install python-rpi.gpio

Далее необходимо подгрузить этот модуль в программу:

import RPi.GPIO as GPIO

Далее следует определиться с порядком нумерации — брать ли «физический» по номерам портов на микрокомпьютере, или использовать принцип обращения по номерам процессорных каналов (BCM):

GPIO.setmode (GPIO.BOARD)
GPIO.setmode (GPIO.BCM)

Преимущество первого пути — универсальность: он будет работать с любой ревизией контроллера. BCM обращается непосредственно к каналам процессора на более низком уровне.

На следующем шаге выбирается режим работы портов input или output.

GPIO.setup(channel, GPIO.IN)
GPIO.setup(channel, GPIO.OUT)

Сразу же можно определить начальное состояние выходов RPi3:

GPIO.setup(channel, GPIO.OUT, GPIO.LOW)
GPIO.setup(channel, GPIO.OUT, GPIO.HIGH)

Команда на чтение информации со входа:

Запись значения на выход GPIO:

Пример работы

Рассмотрим пример взаимодействия RPi3 и простой схемы со светодиодом через написанную на Python программу.

Для начала понадобится «малинка» с установленным ПО и средой разработки, макетная плата, диод, кнопка и резисторы. Схема подключения приведена ниже:

Читайте также  Адаптер usb to usart, spi и i2c

Здесь R1 имеет сопротивление 10 кОм, R2 — 1 кОм, а резистор R3 — 220 кОм.

Что обеспечивает подобная модель:

  • без нажатия кнопки на входе пина возникает напряжение 3.3 В;
  • при нажатии кнопки через нее и резистор R1 начнет подаваться ток 0.33 мА, а на входе схема обеспечит 0 В;
  • при неверном подключении пинов по схеме потечет ток безопасных значений, предохраняя систему от повреждения.

Написанный на Python скрипт включения-выключения лампочки:

Import RPi.GPIO as GPIO
GPIO.setmode (GPIO.BCM)
GPIO.setup (4, GPIO.OUT)
GPIO.output (4, 1)
GPIO.cleanup ()

Для «моргания» диодом:

import RPi.GPIO as GPIO #импорт библиотеки дл¤ работы с GPIO
import time #импорт библиотеки дл¤ ожидани¤
GPIO.setmode(GPIO.BCM) #»запуск» GPIO
GPIO.setup(4, GPIO.OUT) #объ¤вл¤ем 4 порт как выход
while True: #цикл
GPIO.output(4, 1) #вкл светодиода
time.sleep(1) #пауза 1 с
GPIO.output(4, 0) #выкл светодиода
time.sleep(1) #пауза 1 с

Включение лампочки с кнопки:

import RPi.GPIO as GPIO #импорт библиотеки дл¤ работы с GPIO
GPIO.setmode(GPIO.BCM) #»запуск» GPIO
GPIO.setup(4, GPIO.OUT) #объ¤вл¤ем 4 порт как выход
GPIO.setup(3, GPIO.IN) #объ¤вл¤ем 3 порт как вход
while True: #цикл
if GPIO.input(3) == False: #если кнопка нажата
GPIO.output(4, 1) #вкл светодиода
else:
GPIO.output(4, 0) #выкл светодиода

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

import RPi.GPIO as GPIO #импорт библиотеки дл¤ работы с GPIO
GPIO.setmode(GPIO.BCM) #»запуск» GPIO
GPIO.setup(4, GPIO.OUT) #объ¤вл¤ем 4 порт как выход
while True: #цикл
str = input(«Enter — вкл, другое — выход «);
if str != «»:
break
else:
GPIO.output(7, 1)
str = input(«Enter — выкл, другое — выход «)
if str != «»:
break
else:
GPIO.output(7, 0)
GPIO.cleanup()

Готовую программу следует сохранить в удобную папку и запустить командой Питона:

sudo python путь_к_исполняемому_файлу/имя_программы.py

Python предоставляет широкое поле возможностей для программирования «Распберри» и позволяет реализовывать гораздо более сложные схемы. Кроме того, с платой можно взаимодействовать на практически любом распространенном языке — одном из семейства C, Perl, Erlang и другое. Существуют даже реализации проектов на Java и HTML5.

Заключение

GPIO — удобное и универсальное решение, позволяющий подключать к RPi 3 разнообразную периферию и программировать ее поведение на одном из привычных языков. Логика взаимодействия довольно проста, а GPIO, как и сама «малинка», хорошо документирован, что обеспечивает легкий вход в программирование с использованием этого интерфейса даже новичкам в мире IT.

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

Где купить

Видео по теме

Raspberry Pi в Киеве (Украина)

Arduino и многое другое купить в Киеве

В вашей корзине

Raspberry Pi. Урок 4. Настройка GPIO

  • Опубликовано 15.05.2015
  • by leo
  • in Без рубрики

Одно из преимуществ Raspberry Pi — разъем GPIO, с помощью которого можно подключать внешние устройства.

GPIO-разъем обычно состоит из разъемов нескольких типов:

  • Обычные GPIO-выводы (Интерфейс ввода/вывода общего назначения), которые можно использовать для включения и выключения светодиодов и т. п.
  • Интерфейсные выводы I2C, которые позволяют подсоединить модули устройств с помощью всего двух выводов
  • SPI-интерфейс для SPI-устройств. Аналогично к I2C, но другой стандарт
  • Последовательные Rx и Tx выводы для взаимодействия с последовательными периферийными устройствами.

Кроме того, некоторые разъемы могут быть использованы для ШИМ (широтно-импульсная модуляция), для регулировки мощности и для других видов генерирования импульсов для контролирования сервоприводов ФИМ (фазово-импульсная модуляция).

In addition, some of the pins can be used for PWM (pulse Width Modulation) for power control and another type of pulse generation for controlling servo motors called PPM (Pulse Position Modulation).

В этом уроке мы не будем ничего собирать, но Вы узнаете как настроить Raspberry Pi и установить нужные библиотеки, которые позволят сразу же подключать внешнюю электронику.

Этот урок написан исключительно под Raspbian и его производные, например Occidentalis.

GPIO-разъем

На диаграмме ниже показан GPIO-разъем для Raspberry Pi Версия 1 (которая была последней версией на момент написания урока). У второй версии вместо вывода 21 вывод 27, но в целом суть та же.

Все GPIO-выводы могут использоваться для подачи питания (земля, 3,3В и 5В), а также как цифровые вводы или выводы. Выводы SCL и SDA могут быть использованы для I2C. Выводы MOSI, MISO и SCKL могут быть использованы для подключения высокоскоростных SPI-устройств.

Все выводы имеют логические уровни 3,3В и не подходят для 5В, поэтому уровень на выходе 0-3,3В а уровень на входе не должен превышать 3,3В. Если Вы хотите подсоединить 5В-вывод, используйте схему сдвига уровня.

Распространенный способ подключения Raspberry Pi — с помощью Pi Cobbler.

Код для Pi

Чтобы упростить жизнь тем, кто хочет экспериментировать с подключением электроники к Pi, Adafruit предоставили огромную коллекцию очень полезного кода, в том числе простые библиотеки Python для огромного количества модулей, включая дисплеи, сенсоры, ШИМ-контроллеры и т п.

Чтобы получить этот код, Вам понадобится программа’git’. В Occidentalis она установлена заранее, но на Raspbian ее нужно установить с помощью следующих команд LX Terminal.

Ярлык LX Terminal на Рабочем столе.

Прежде всего введите следующую команду в LXTerminal. Таким образом Ваш пакет точно будет найден и обновлен до последней версии. Не важно в каком каталоге Вы находитесь.

Как только git установится (если он еще не установлен), Вы сможете зайти в каталог Adafruit Pi Python со своего Pi с помощью следующих команд:

git clone http : //github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git

cd Adafruit — Raspberry — Pi — Python — Code

Если возникнут какие-либо проблемы во время выполнения предыдущих шагов, появится сообщения об ошибке. Наиболее распространенные причины ошибок при установки:

  • проблемы с Интернет-подключением
  • неправильно введенная команда. Помните, что Линукс чувствителен к регистру. Поэтому проще всего просто открыть эту страницу на Raspberry Pi, скопировать и вставить команды.

Настройка GPIO

GPIO могут быть использованы как цифровые вводы, так и цифровые выводы. В случае цифровых выводов, можно писать программы, которые смогут задавать значения конкретного контакта HIGH или LOW. HIGH задает значение 3,3В, а LOW — 0В. Чтобы управлять светодиодом через один из GPIO, Вам понадобится резистор на 1кОм последовательно подсоединенный к светодиоду, поскольку контакты GPIO могут выдерживать только небольшие количества тока.

Если Вы используете контакт как цифровой ввод, подсоедините переключатели и простые сенсоры к контакту и тогда Вы сможете проверить открыт он или закрыт (то есть активирован или нет).

Чтобы запрограммировать разъемы GPIO на Python, требуется установить библиотеку для Python 2, которая называется Rpi.GPIO. Эта библиотека проста в использовании и позволяет управлять GPIO.

Процесс установки для Raspbian и Occidentalis один и тот же. На самом деле, некоторые версии Raspbian содержат эту библиотеку, но Вы можете обновить ее до более новой версии, что стоит делать:

Чтобы установить RPi.GPIO, сначала установите набор программ Python Development, который требует RPi.GPIO

Введите следующую команду в LXTerminal:

sudo apt — get install python — dev

Чтобы установить сам Rpi.GPIO введите:

sudo apt — get install python — rpi . gpio

Скорее всего появится запрос на подтверждение. Нажмите ‘Y’.

Настройка I2C

I2C — очень распространенный стандарт, который разработан для коммуникации между чипами. Поскольку Raspberry Pi может взаимодействовать с I2C, мы можем подключать множество чипов и модулей с поддержкой I2C.

Шина I2C позволяет множеству устройств подключаться к Raspberry Pi с помощью уникальных адресов, которые можно задавать изменив настройки джамперов на модуле. Очень удобно иметь возможность увидеть какие устройства подключены к Pi. Так можно убедиться, что все работает.

Чтобы это сделать, нужно установить программу i2c-tools с помощью кода:

sudo apt — get install python — smbus

sudo apt — get install i2c — tools

Установка Kernel Support (с помощью Raspi-Config)

Запустите sudo raspi-config и следуйте подсказкам, чтобы установить поддержку i2c для ARM core и linux kernel

Мы также рекомендуем просмотреть шаги ручной настройки, чтобы удостовериться, что все было сделано raspi-config!

Установка Kernel Support (вручную)

Если Вы используете Occidentalis, то Ваш Pi поддерживает I2C насколько это позволяет аппаратное обеспечение. Однако если у Вас Raspbian, Вам нужно будет открыть LXTerminal, консоль или ssh и ввести следующую команду:

и добавить эти две строки в конце файла:

Теперь сохраните Control-X Y

В зависимости от Вашего дистрибутива, Ваш файл может называться /etc/modprobe.d/raspi-blacklist.conf

Если файл отсутствует, то ничего делать не нужно. Но если он у Вас есть, нужно внести изменения и закомментировать строки:

blacklist i2c — bcm2708

sudo nano / etc / modprobe . d / raspi — blacklist . conf

Если у Вас новая версия Raspberry Pi (ядро 3.18 или выше), Вам также нужно будет обновить файл /boot/config.txt file. Edit it with sudo nano /boot/config.txt и добавить следующий текст внизу:

dtparam=i2c1=on
dtparam=i2c_arm=on

Обратите внимание, что «1» в»i2c1″ — единица, а не L!

Когда закончите, перезагрузитесь!

Тестирование I2C

После входа введите следующую команду, чтобы увидеть все подключенные устройства (если у Вас 512MB Raspberry Pi Model B)

Это значит, что используются 2 адреса – 0x40 and 0x70.

Если у Вас одна из самых первых версий Raspberry Pi (256MB Raspberry Pi Model B), Вам нужно будет ввести такую команду:

Разработчики Raspberry Pi поменяли местами разъемы I2C. Просто запомните: 512M использует для i2c разъем 1, а 256M разъем 0!

Настройка SPI

Для начала уберите черный список spi-модуля:

sudo nano / etc / modprobe . d / raspi — blacklist . conf

blacklist spi-bcm2708

и поставьте # в начале. Вот так:

Теперь введите control-X Y, нажмите клавишу ввода и сохраните файл.

Перезагрузитесь sudo reboot

При следующем входе проверьте, что Вы можете видеть устройства с помощью:

Вы должны видеть 2 устройства: по одному на каждую SPI шину