8-900-374-94-44
Программирование Raspberry Pi 3 – это как раз то, для чего большинство людей и берет этот одноплатный компьютер. Здесь сразу же следует отметить, что в этом материале не будет изложено инструкций, подробно раскрывающих, как и что нужно делать – таких в «сети» полно. Однако, рекомендуется читать официальную документацию и специализированные формы. Вместо этого в статье будут рассмотрены основные моменты, из которых станет понятно, что на Raspberry Pi программирование не отличается сложностью.
Почти все владельцы Raspberry Pi понимают, что означает первое слово в названии одноплатника – «малина». Однако второе многие интерпретируют неверно.
Некоторые считают, что оно означает «Пи» (3,14…), другие думают, что это первые две буквы слова Pie (пирог, и в этом есть смысл – «малиновый пирог»). Однако на деле все иначе.
Pi – это сокращение от Python, только с заменой y на i. Так часто делают в программировании. Взять, например, хотя бы KDE, где во многих программах вместо С написано K (в угоду стилю): Konsole (правильно – Console), Konqueror (Conqueror) и т. д.
То есть, как не трудно догадаться, в Raspberry основным языком является «Пайтон». Поэтому владельцу «Малины», который пока не знает никакого ЯП, рекомендуется изучать именно этот. Причин, почему Raspberry Pi 3 программирование на Python наиболее лучшее решение, существует множество.
Вот лишь некоторые из них:
Здесь по понятным причинам не будем рассказывать о языке и особенностях программирования на нем – это можно и нужно делать на официальных ресурсах (или, если не позволяет плохое знание английского – на специализированных).
Вместо этого будет рассмотрено, насколько легко можно программировать «Малину». Для примера возьмем Raspberry Pi 3 GPIO программирование. Сделаем предположение, что в наличии имеется все необходимое: провода, светодиод, резистор и прочее, а также присутствует понимание распиновки – нумерации пинов. Также предположим, что светодиод подключен к 11 порту.
Написанный ниже код включает лампочку на 5 секунд, а затем выключает ее:
# вначале подключим необходимую библиотеку
import RPi.GPIO as GPIO
# также понадобится библиотека, которая отвечает за ожидание (она нужна, чтобы установить интервал включения и выключения лампочки)
import time
# чтобы запустить GPIO, понадобится выполнить следующую функцию
GPIO.setmode(GPIO.BOARD)
# теперь Python знает о GPIO, и ему можно указать на то, с каким портом нужно будет работать и что он должен делать (в данном случае – 11-м и он будет работать на выход)
GPIO.setup(11, GPIO.OUT)
# далее включим лампочку на 5 секунд (11 – номер порта, а 1 – значит true)
GPIO.output(11, 1)
time.sleep(5)
# теперь выключим (0 – значит false)
GPIO.output(11, 0)
Указанный код можно скопировать, вставить в документ и сохранить его с расширением .py, расположив, например, в домашней директории. Затем его нужно запустить командой: python ~./имя_файла.py.
Если все работает, то оборудование исправно.
Следует отметить, что, если вы плохо понимаете вышеуказанный код, обратитесь к документации и изучите основы программирования на Python, а также библиотеку GPIO. А если у вас есть хотя бы базовое понимание любого ЯП, то осознаете, что приведенный пример предельно прост.
Программирование на C для Raspberry Pi или на других языках программирования почти ничем не отличается от того, что предполагает написание кода под другими платформами. Единственное – необходимы специальные библиотеки.
Если интересует Raspberry Pi программирование на C/С++ и работа с GPIO, то требуется установить в систему непосредственно сам gcc, а затем библиотеку wiringPi – ее можно найти на GitHub. В описании к ней присутствует мануал по использованию.
Следует отметить, что для установки библиотек из GitHub, требуется утилита GIT. Если в системе ее нет, понадобится поставить из репозитория (полное имя: git-core).
Желающие программировать Raspberry Pi на Java, должны обратить внимание на Pi4J – библиотеку, которая предназначена специально для работы с «Малиной». Загрузить и узнать о ее особенностях можно на официальном сайте проекта.
Интересно то, что изначально «Малина» разрабатывалась непосредственно для обучения детей программированию. Создатель этого устройства заметил, что уровень понимания функционирования компьютеров у современных студентов значительно ниже, чем у тех, кто учился в 90-х. Он связал это с тем, что вычислительные устройства стали предельно просты: если раньше увлеченным электроникой детям и подросткам приходилось разбираться в командах терминала и даже самостоятельно писать код, теперь все делается посредством нажатия на пару кнопок.
Поэтому, естественно, предусмотрено визуальное программирование Raspberry Pi. В частности, для этого применяется язык Scratch со специальным сервером – GPIOSERVER. В Сети существует множество мануалов, которые помогают освоиться с соответствующими программами, поэтому рассматривать их смысла нет.
Перечисленными языками не ограничиваются возможности «Малинки». С ней можно взаимодействовать в том числе и при помощи PHP, Ruby, Perl и прочих ЯП. Почти под каждый популярный язык существуют хоть и не официальные, но зато рабочие и достаточно функциональные библиотеки. Однако опять следует упомянуть, что лучше для программирования Raspberry использовать именно «Пайтон».
myraspberry.ru
RPi – компьютер, который получил столь высокую популярность во многом благодаря наличию встроенного интерфейса ввода/вывода. Используя его, можно создавать всевозможные гаджеты: от простых метеостанций и портативных игровых приставок до систем умного дома. У Raspberry Pi 3, конечно, тоже имеется GPIO. И он мало чем отличается от тех, который присутствует в других моделях.
Чтобы работать с GPIO Raspberry Pi 3, необходимо знать его схему. Собственно, это является самым важным. Из текста ниже, в свою очередь, вы узнаете о том, какие пины за что отвечают. А, чтобы иметь лучшее представление об устройстве GPIO, рекомендуется скачать соответствующую схему, выполненную в графике.
Новичкам будет полезно узнать о том, что собой представляет GPIO. Это интерфейс, который предназначен для обеспечения связи между компонентами компьютера. В случае с «Малиной» он необходим для работы основной системы с дополнительными компонентами, которые называются модулями.
Пины в GPIO могут выполнять 3 функции:
Интересно то, что за вход и выход в интерфейсе могут отвечать одни и те же контакты. По крайней мере это справедливо для RPi. То, как они себя должны вести, определяется программой.
Теперь можно перейти к вопросу, который касается того, какая распиновка GPIO имеется на Raspberry Pi 3. В первую очередь необходимо сказать, что общее количество пинов на соответствующей панели равняется 40. Каждый из них имеет свой номер.
Все они подразделяются на 3 группы. К первой относятся питающие (на англоязычных схемах маркируются как Power) – они подают электричество в 3,3 и 5 Вольт. При этом у разных контактов данного назначения различное напряжение. Это обязательно следует учитывать при подключении модулей.
Ко второй – заземляющие (могут именоваться RND или Ground). Они нужны, чтобы отводить электричество, тем самым обеспечивая безопасное использование.
К третьей – порты (имеют обозначение BCM). Именно они служат теми контактами, которые могут принимать и отправлять сигналы. Пользователь может подключать модули к любым из них. Самое главное – чтобы было удобно обеспечивать питание подсоединённых компонентов.
Разобравшись с тем, какие типы контактов присутствуют в GPIO, можно перейти непосредственно к тому, какие из них конкретно за что отвечают. Самый простой способ освоить распиновку – это изучить схему. Но если такой возможности нет, можно обойтись и описанием.
Предположим, что плата расположена горизонтально таким образом, что GPIO на ней находится в левом верхнем углу. В таком случае номера портов будут располагаться так:
Из списка выше должно быть понятно, по какому принципу выполнена нумерация соответствующего интерфейса. Теперь можно перейти к тому, контакты под какими номерами имеют какое назначение.
Питающие на 3,3 Вольта – 1 и 17, а на 5 Вольт – 2 и 4 (они находятся рядом). Заземляющие внизу – 9, 25 и 39, заземляющие вверху – 6, 14, 20, 30 и 34. Все остальные контакты – это порты (BCM).
Чтобы начать использование GPIO в Raspberry Pi 3, необходимо знать какие существуют особенности нумерации контактов у данного интерфейса. Важно понимать, что в процессоре «Малины» не записаны номера пинов, которые не работают на вход/выход, то есть не являются портами.
Поэтому при управлении GPIO на Raspberry Pi 3 необходимо знать нумерацию BCM. Она в значительной степени отличается от той, которая рассмотрена в разделе выше. Так, 3 контакт (он является портом) имеет номер BCM2. Именно такой следует указывать при написании кода.
Понятно, что из-за этого может возникнуть путаница. Ввиду этого на Raspberry Pi 3 рекомендуется использовать Wiring Pi. Это специальная библиотека, которая имеет собственную нумерацию. Так, например, 3 порт (который является BCM 2) определяется как WiringPi 8. Возможно, это покажется еще более нелогичным. Но после ознакомления с соответствующей схемой все встанет на свои места.
Модули возможно подключать к абсолютно любым портам GPIO «Малины», и они будут нормально работать. Но важно знать, что в системе есть пара контактов, которые зарезервированы системой для особых целей. Ими являются BCM 0 и BCM 1 (их номера на обычной схеме – 27 и 28). Они предназначаются специально для установки плат расширения. Поэтому при возможности их не нужно использовать для подключения других модулей.
Еще один важный момент – осторожное использование питания через GPIO Raspberry Pi 3. Ток на внешние устройства через «Малину» может подаваться с силой до 50 мА. Это достаточно много для столь небольшого девайса. Поэтому подавать ток под такой силой нужно только по крайней необходимости. В противном случае можно не только испортить модуль, но и процессор самой RPi.
Купить
Raspberry PI
Проверенный поставщик
MyRaspberri.ru рекоммендует
Работать с GPIO «Малины» можно посредством языков программирования. Вариантов здесь существует много. Самый лучший для GPIO Raspberry Pi 3 – Python. Это связано с тем, что для этого одноплатника данный ЯП является «родным». Но с не меньшим успехом с интерфейсом возможно взаимодействовать и посредством C/C++ и даже PHP или Basic. Язык каждый выбирает под себя.
Как возможно убедиться, распиновка GPIO на RPi3 не является какой-то сложной. Единственное – по неопытности в ней можно немного запутаться. Чтобы этого не происходило, рекомендуется загрузить на компьютер схему расположения контактов. При этом лучше не одну, а несколько (обычную, BCM и WiringPi). Так будет удобно и подключать модули, и взаимодействовать с ними через программные инструменты.
myraspberry.ru
Raspberry Pi – мощная платформа для обработки информации, полученных от разнообразных устройств. Этот микрокомпьютер может стать основой для создания систем умного дома и устройств распознавания образов. Наиболее удобной и популярной средой программирования для Raspbian является Питон. В это статье мы узнаем, как настроить Python на Raspberry Pi и как установить библиотеку RPI.GPIO для работы с GPIO портами.
Python – один из самых известных и используемых языков программирования. Изначально язык Python должен был выступать в роли основного языка программирования для Raspberry Pi. В микрокомпьютере Raspberry Pi он используется для работы с датчиками через GPIO при помощи специальной библиотеки. Пакет Python уже установлен в операционной системе Raspbian в двух версиях – 2 и 3. Каждый элемент в системе Raspbian перед именем имеют приставку «python-».
Установка и инсталляция пакетов выполняются с помощью утилиты apt либо pip.
Установить пакет утилитой apt можно при помощи команд:
sudo apt-get update
sudo apt-get install python3-picamera
Это один из лучших методов установки программного обеспечения. Благодаря такой установке программы можно легко обновить до последней версии – для этого используются команды sudo apt-get update и sudo apt-get upgrade.
Удалить ненужные элементы можно, запустив команду sudo apt-get remove python3-rpi.gpio.
Полное удаление можно произвести, добавив к команде окончание –purge:
sudo apt-get remove python3-rpi.gpio –purge.
Установка пакетов через PIP. Этот инструмент нужно тогда, когда невозможно найти нужный пакет или его последнюю версию. В это случае установка проводится через PyPI – каталог пакетов Python. Установка так же не вызывает трудностей, как и в предыдущем случае. Сначала нужно установить пакет через apt:
sudo apt-get install python3-pip (на примере третьей версии)
Команда pip-3.2 устанавливает нужные документы и файлы для python. Например, установить любую библиотеку можно следующим образом:
pip-3.2 install library
Удалить – с помощью команды
pip-3.2 uninstall.
Сам язык программирования Python характеризуется простым синтексом и высокой функциональностью, поддерживает автоматическое управление памятью, многопоточность вычислений, обработку исключений. Для этого языка существует большое количество библиотек для самых разнообразных сфер применения. Существуют расширения для создания игр – Pygame, для работы с мультимедиа, обработки графики, различных вычислений.
Библиотека RPi.GPIO написана специально для управления портами GPIO на языке python. Эти порты позволяют собирать данных с датчиков, управлять двигателями, ключами, реле и прочими устройствами с помощью программы.
В первую очередь нужно скачать архив с официального сайта https://sourceforge.net/projects/raspberry-gpio-python/files/?source=navbar. На странице можно увидеть большое количество версий библиотеки. Нужно выбрать самую свежую версию.
Архив будет загружен в папку загрузки по адресу /home/pi/Downloads. Нужно зайти в нее, найти скачанный архив, нажать правую кнопку мыши и выбрать во всплывающем меню Extract Here.
Эта команда разархивирует библиотеку в папку, в которую помещен архив. Рядом с ним будет добавлена новая папка с названием RPi.GPIO-0.6.3.
Следующим шагом нужно установить python-dev. Запускается терминал и в него вводится команда
sudo apt-get install python-dev
Будет задан вопрос «Do you want to continue? [Y/n]», нужно нажать «Yes» и Enter.
В окне высветится отчет, который сообщает об успешно проведенной установке.
Чтобы установить библиотеку RPi.GPIO, нужно не закрывая перейти в папку, которая была распакована до этого.
cd /home/pi/Downloads/RPi.GPIO-0.6.3
Затем нужно запустить команду:
python setup.py build
На экране появится отчет о выполнении.
После этого нужно запустить установку библиотеки с помощью команды
sudo python setup.py install
После успешной установки на экране появится новый отчет.
Библиотека установлена, можно начинать работать.
Помимо вышеописанной библиотеки RPi.GPIO существуют и другие. Для доступа к GPIO контактам используется также библиотека WiringPi. Эта библиотека написана на языке C, используется в средах C, C++ и RTB (BASIC) и других. Она создавалась схожей с библиотекой Wiring на Ардуино.
Для программирования и настройки контактов вместе с библиотекой используется утилита gpio для командной строки. Она позволяет записывать и считывать данных с портов и управлять ими.
arduinomaster.ru
Raspberry Pi не был бы таким популярным, если в нём не предусмотрели GPIO. Этот интерфейс ввода/вывода позволяет сделать из одноплатника практически все что угодно – от удаленных управляемых машинок до систем «умного дома».
У Raspberry Pi GPIO действительно является очень мощным решением, при помощи которого возможно реализовать многие задумки. Но прежде, чем его эксплуатировать на полную катушку, необходимо научиться с ним работать. И как везде, начинать следует с самых простых, базовых вещей.
В первую очередь необходимо рассмотреть ключевые особенности этого интерфейса. И самое главное в GPIO Raspberry Pi – это pings (пины). Именно они используются для связи одноплатника с периферией.
В совокупности у «Малины» есть 26 GPIO (портов), однако самих элементов больше:
Все они выстроены в 2 ряда. Если расположить плату горизонтально и так, чтобы интерфейс оказался вверху, то к первой паре элементов можно подключать (запитывать) устройства, требующие напряжения в 5 Вольт. Снизу, в свою очередь, находится 1 на 3,3, а второй такой же располагается в этом же ряду, примерно посередине – между 22 и 10 портами.
Чтобы ознакомиться с распиновкой GPIO Raspberry следует изучить схему. Её рекомендуется загрузить на компьютер, чтобы при необходимости можно было быстро обратиться к данной информации – заучить сразу расположение всех элементов не получится.
Работать с GPIO Raspberry Pi можно практически через любой инструмент. К сегодняшнему дню созданы соответствующие библиотеки почти под все распространенные языки программирования. С GPIO Raspberry Pi возможно взаимодействовать даже через PHP и JavaScript (node.js).
Однако человеку, который только начинает знакомиться с «Малиной», рекомендуется пробовать взаимодействовать с данным интерфейсом посредством Python. Это обусловлено, во-первых, что для GPIO в Raspbian уже предустановлена соответствующая библиотека для Пайтона, а, во-вторых, этот ЯП является основным для рассматриваемого одноплатника.
Однако при желании, конечно, возможно пользоваться и любыми другими инструментами. Найти название библиотек и описание их не составляет никакого труда.
Купить
Raspberry PI
Проверенный поставщик
MyRaspberri.ru рекоммендует
Для удобства можно установить дополнительное ПО, которое позволит более эффективно взаимодействовать с интерфейсом «Малины». Например, некоторые из них позволяют работать с GPIO без соответствующих привилегий.
К таким утилитам, в частности, относятся: quck2wire-gpio-admin и WiringPi GPIO utility. Первая из них является более функциональной.
Если требуется прямой доступ к портам, также можно инсталлировать еще и PRIO. Расписывать принцип его работы и вышеуказанных программ нет смысла, так как всю необходимую информацию возможно получить из официальной документации.
Следует отметить, что любые из указанных программ возможно легко найти в репозитории Raspbian.
И теперь самое интересное: как выполняется управление GPIO Raspberry Pi через Пайтон.
Абсолютно отсутствует необходимость рассказывать о самом языке Python и подробно описывать библиотеку. Эту информацию легко найти на официальных сайтах соответствующих проектов – лучше изложить материал, чем там, крайне тяжело.
Однако есть смысл просто продемонстрировать некоторые принципы взаимодействия с GPIO. Конечно, перед написанием кода следует подключить устройство, с которым нужно работать к GPIO.
Первое, что потребуется сделать – это подключить библиотеку, делается это так: import PRi.GPIO as GPIO.
Далее нужно дать интерпретатору понять, что обращение к портам будет выполняться по их названиям. Это выполняется инструкцией: GPIO.setmode(GPIO.BCM). Предварительно также рекомендуется сбросить текущее состояние интерфейса (мало ли каково оно, хотя это и не критично) – GPIO.cleanup().
Далее можно сконфигурировать порты на выход и вход. Первое делается так: GPIO.setup(НОМЕР_ПОРТА, GPIO.OUT), а второе – GPIO.setup(НОМЕР_ПОРТА, GPIO.IN).
То есть, как можно убедиться, абсолютно ничего сложного в работе с GPIO нет. Главное – знать название портов (возможно почерпнуть из схемы) и функции, предусмотренные библиотекой.
В завершении следует резюмировать все вышесказанное. Если вы хотите работать с GPIO, то вам потребуется следующее:
Даже с нуля и без знания ЯП в GPIO Raspberry возможно более или менее освоиться за пару вечеров. Работать с интерфейсом «Малины» очень просто. Это связано с тем, что данный одноплатник создавался, в том числе с целью обучения людей взаимодействия с компьютерами на уровне железа. Конечно, ничего сложного без глубоких знаний сделать не получится. Но так происходит всегда в процессе обучения. Со временем, с приобретением знаний и опыта можно будет реализовывать все более и более интересные вещи.
myraspberry.ru
Порты 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, доступной здесь.
Устанавливается пакет следующей командой:
$ sudo pip install RPIO
Кроме 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()
habr.com
Порт GPIO (сокращение от General Purpose Input Output) — это программно управляемые выводы общего назначения, которые могут работать как входы (для считывания сигнала) или как выходы (для передачи сигнала). На Raspberry Pi они выполнены в виде двух рядов штырьков с шагом в 2,54 мм (разъем PLD). Выражение «общего назначения» означает, что эти выводы пользователь может использовать в своих целях так, как ему захочется, поскольку они не выполняют каких-то определенных жестко заданных функций. При работе с GPIO следует только иметь ввиду, что это цифровые выводы с максимальным уровнем напряжения 3,3 В, соответствующим логической единице. Поэтому программно выводить на GPIO аналоговый сигнал или подавать на него аналоговый сигнал извне для последующий оцифровки нельзя.Итак, что представляет собой порт GPIO и каковы его возможности? GPIO объединяет в себе 26 выводов, среди которых присутствуют следующие:
Примечание: Это знакомые понятия для тех, кто сталкивался с программированием микроконтроллеров. Для тех, кто не сталкивался и на данном этапе пока желает просто программно выводить «1» и «0» на нужном выводе — знания этих интерфейсов не понадобится. Поэтому не буду здесь уделять этому внимание. Скажу только, что среди микроконтроллеров и других устройств (различные датчики, АЦП, ЦАП, микросхемы памяти) это очень распространенные интерфейсы, поэтому наличие выводов этих интерфейсов в GPIO Raspberry при необходимости позволяет очень легко и с минимумом программного кода «научить» Raspberry «общаться» с вашим устройством.
Как понять где какой вывод находится? Для этого необходима распиновка (цоколевка) GPIO. В официальной документации приведена распиновка разных версий GPIO Raspberry Pi. Здесь я приведу самую последнюю на данный момент распиновку GPIO — для Raspberry Pi Model B Rev.2:
На схеме в скобках указана альтернативная функция каждого вывода:
Пожалуй, это самый важный раздел. Нужно помнить о некоторых особенностях GPIO и соблюдать определенные меры предосторожности, чтобы не залететь еще на 35-50$ не повредить Raspberry. Ниже приведены такие «критические особенности», а также несколько нюансов, которые просто могут быть полезны, и которые желательно помнить при разработке.
Пожалуй, все.. Ну и в целом нужно помнить, что GPIO — это выводы, непосредственно подключенные к процессору Raspberry Pi, они являются инструментом для взаимодействия с ним. Поэтому неосторожное обращение с GPIO может привести к необратимым последствиям для процессора. На этом с «пугалками» заканчиваю. Главное и простое правило — не подавать больших напряжений и не потреблять большой ток. Переходим к делу.
0) Для работы с GPIO на Python нужна специальная библиотека RPi.GPIO. Сейчас ее можно установить прямо с репозиториев, а не качать архив и устанавливать вручную, как было раньше. Воспользуемся этой возможностью:
sudo apt-get install python-rpi.gpio (или python3-rpi.gpio для 3-й версии Питона)
Оказывается, в новом дистрибутиве Raspbian она уже установлена, поэтому двигаемся дальше.
0.5) GPIO является системным элементом Raspbian, поэтому работать с ним нужно только под суперпользователем. Будем писать программу прямо в консоли, поэтому запускаем python:
sudo python
1) Импортируем библиотеку для работы с GPIO:
import RPi.GPIO as GPIO 2) Устанавливаем способ нумерации выводов GPIO.
Зачем? Дело в том, что во многих функциях этой библиотеки необходимо указывать номер вывода, над которым мы хотим произвести какую-либо манипуляцию. Однако указываемый номер можно интерпретировать по-разному: либо это номер GPIO, либо это номер пина (P1-26) на плате Raspberry (см. распиновку). Чтобы не возникало путаницы, сразу после импорта желательно «указать библиотеке», какую нумерацию мы будем использовать в программе.
GPIO.setmode(GPIO.BCM) #GPIO.BCM — будет использоваться нумерация GPIO
#GPIO.BOARD — будет использоваться нумерация пинов P1-26
Примечание: именно после выполнения этой команды на GPIO 7 установится ровно 0 В, поскольку этот вывод больше не является входом и на нем нет «плавающего» потенциала.
С помощью необязательного параметра pull_up_down функции setup можно также настроить «подтяжку» вывода к питанию или к земле:
GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_UP) #подтяжка к питанию 3,3 В
GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #подтяжка к земле 0 В
GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_OFF) #режим по-умолчанию
4) Формируем и считываем сигналы
Формируем «1» и «0» на GPIO 7 и считываем сигнал с GPIO 8:
GPIO.output(7, True) #выводим на GPIO 7 логическую «1» (3.3 V)
GPIO.output(7, False) #выводим на GPIO 7 логический «0»5) Завершаем работу
После всех нужных операций корректно завершаем работу:
GPIO.cleanup()
Выполнение этой операции приведет к возвращению всех выводов GPIO в первозданное состояние.
Примечание: если не выполнить эту операцию, то даже после закрытия программы и выхода из python, выводы GPIO останутся в том, состоянии, в котором они были на момент завершения. Это может быть чревато тем, что при попытке повторно поработать с этими выводами будет возникать сообщение, о том, что вывод уже используется: «RuntimeWarning: This channel is already in use, continuing anyway.»
Весь пример целиком:
import RPi.GPIO as GPIO #подключаем библиотеку
GPIO.setmode(GPIO.BCM) #устанавливаем режим нумерации
GPIO.setup(7, GPIO.OUT) #конфигурируем GPIO 7 как выход
GPIO.setup(8, GPIO.IN) #конфигурируем GPIO 8 как вход
GPIO.output(7, True) #выводим на GPIO 7 логическую «1» (3.3 V)
GPIO.output(7, False) #выводим на GPIO 7 логический «0»
signal = GPIO.input(8) #считываем сигнал с GPIO 8 в переменную signal
GPIO.cleanup() #завершаем работу с GPIO
На мой взгляд, из всех характеристик наиболее интересны временные параметры GPIO, а именно — насколько быстро может меняться состояние цифрового вывода из «1» в «0» и обратно, если управлять портом программно. Для проверки этого использовался следующий код:
Примечание: частота импульсов, изображенных на верхних картинках, может незначительно колебаться. Это связано с тем, что Linux на Raspberry многозадачна и не всегда уделяет нашей программе все процессорное время. Также следует иметь ввиду, что добавление дополнительных команд внутрь цикла while может существенно увеличить время каждого импульса.
По нижним картинкам можно оценить время переключения пина GPIO из одного состояния в другое (другими словами длительность переходного процесса) — оно составляет приблизительно 50 нс. Надо сказать, довольно неплохие результаты, однако и конкурировать по скорости с ПЛИС GPIO Raspberry Pi не может.
Как можно применить все это на практике? Зачем выводить «1» или «0» на GPIO? Например, можно помигать светодиодами! Например, можно управлять силовой нагрузкой и включать / выключать любые бытовые приборы, работающие от сети 220 В. Для этого понадобится Raspberry Pi и всего 7 деталей. Схема такого программного «выключателя» приведена ниже:
Примечание: микросхема-оптодрайвер MOC3041M имеет гальваническую развязку силовых цепей от слаботочных, поэтому она является «барьером безопасности» между Raspberry и сетью 220 В, выход ее из строя не повредит Raspberry. Конденсатор C8 должен быть высоковольтным и выдерживать напряжение ~400 В.
Данная схема может коммутировать токи до 16А. Она полностью отлажена, проверена на практике и занимает очень мало места (к сожалению, у меня не сохранились фото устройства, где она используется). Подача «1» на GPIO 7 Raspberry Pi приведет к срабатыванию оптодрайвера и открытию симистора V2, который начнет пропускать через себя ток, идущий от сети 220 В к силовой нагрузке. Прибор включается. Как только на GPIO 7 возникает «0» — симистор V2 закрывается и цепь нагрузки размыкается. Прибор выключается. Все просто!
Применение же именно Raspberry Pi позволяет управлять нагрузкой программно, по расписанию, при наступлении каких-либо внешних событий или подаче сигналов (к примеру, сигнал с пульта для открытия ворот) и даже через Интернет (например, посредством собственного веб-сайта, работающего на том же Raspberry). Одним словом, Raspberry помогает развивать фантазию.
На этом все. В следующем посте о Raspberry постараюсь описать работу с UART и SPI.
hexvolt.blogspot.com
В этой статье мы поговорим о том, как подключать к Raspberry Pi датчики и другие внешние устройства через GPIO порты платы. Для работы будем использовать Python и библиотеки. Если вы новичок в работе с распбери, рекомендуем прочитать статью об установке Python и библиотек для Raspberry Pi.
Среди любителей радиотехники и электроники каждый слышал о существовании таких устройств как Arduino и Raspberry Pi. Обе платы используются для решения схожих задач, оба прекрасно подходят для начинающих. Но по сравнению с Ардуино Raspberry – это многофункциональный компьютер, на котором может запускаться операционная система.
Из основных отличий можно выделить тактовую частоту – Raspberry работает в 40 раз быстрее Ардуино, и объем оперативной памяти – у Raspberry памяти больше примерно в 128000 раз. За счет простоты управления и использования разрабатывать аппаратные проекты на Ардуино предпочтительнее. Ардуино может работать с любыми датчиками или чипами, а Raspberry Pi не такая гибкая, для работы с датчиками требуются дополнительные аппаратные устройства. Raspberry Pi очень требовательна к питанию, напряжение должно быть строго 5 В на входе, в то время как для ардуино рекомендуемое питание 7-12 В, которое стабилизируется до 5 В.
Важное отличие заключается в среде, в которой пишется программа. С Arduino IDE работать намного проще, чем с Linux. Установка библиотек для написания программы требуется для обеих систем, но код на Ардуино будет написан проще и короче.
Raspberry Pi возможно использовать в режиме многозадачности, как обычный компьютер. Одновременно может работать несколько программ в фоновом режиме.
Для расширения возможностей можно совместно использовать обе платы. Для управления датчиками и сенсорами использовать Ардуино, а сложные вычислительные задачи оставить для Raspberry Pi.
Количество портов в более старых и новых моделях Raspberry Pi отличается –model A и model B оснащены 26 выводами общего назначения GPIO, в следующих версиях количество выводов увеличено до 40.
Существует несколько видов обозначений выводов:
Расположение контактов изображено на рисунке. На картинке для удобства последние 14 контактов отделены – это и есть новые выходы, которые были добавлены в новых версиях платы.
| Номер вывода | BCM | WiringPi | Описание контакта |
| 1 | 3v3 | Питающий контакт на 3,3В | |
| 2 | 5v | Питающий контакт на 5 В | |
| 3 | BCM2 | 8 | SDA |
| 4 | 5v | Питающий контакт на 5 В | |
| 5 | BCM3 | 9 | SCL |
| 6 | GND | Земля | |
| 7 | BCM4 | 7 | GPCLK0 |
| 8 | BCM14 | 15 | TXD – отвечает за передачу данных |
| 9 | GND | Земля | |
| 10 | BCM15 | 16 | RXD – отвечает за прием данных |
| 11 | BCM17 | 0 | Вывод общего назначения |
| 12 | BCM18 | 1 | PCM_C – используется в сочетании с ШИМ-методом. |
| 13 | BCM27 | 2 | Контакт общего назначения |
| 14 | GND | Земля | |
| 15 | BCM22 | 3 | Контакт общего назначения |
| 16 | BCM23 | 4 | Контакт общего назначения |
| 17 | 3V3 | Питающее напряжение 3,3В | |
| 18 | BCM24 | 5 | Контакт общего назначения |
| 19 | BCM10 | 12 | MOSI |
| 20 | GND | Земля | |
| 21 | BCM9 | 13 | MISO |
| 22 | BCM25 | 6 | Контакт общего назначения |
| 23 | BCM11 | 14 | SCLK |
| 24 | BCM8 | 10 | CS0 |
| 25 | GND | Земля | |
| 26 | BCM7 | 11 | CS1 |
| 27 | BCM0 | 30 | ID_SD |
| 28 | BCM1 | 31 | ID_SD |
| 29 | BCM5 | 21 | Контакт общего назначения |
| 30 | GND | Земля | |
| 31 | BCM6 | 22 | Контакт общего назначения |
| 32 | BCM12 | 26 | Контакт общего назначения |
| 33 | BCM13 | 23 | Контакт общего назначения |
| 34 | GND | Земля | |
| 35 | BCM19 | 24 | MISO |
| 36 | BCM16 | 27 | Контакт общего назначения |
| 37 | BCM26 | 25 | Контакт общего назначения |
| 38 | BCM20 | 28 | MOSI |
| 39 | GND | Земля | |
| 40 | BCM21 | 29 | SCLK |
Выводы земля, напряжение питания и другие аналогичные можно использовать любые, которые будут удобнее в конкретном проекте. Важно следить за тем, чтобы напряжение на GPIO было 3,3В, иначе контакт может быть вывеен из строя.
Среди выводов общего назначения имеются UART-контакты (на восьмом и десятом контактах). Они позволяют обеспечить взаимодействие Ардуино и Raspberry Pi. Также 4 вывода поддерживают I2C, главной задачей которых является коммуникация с периферией. Для верификации в коде нужно добавить строки
sudo apt-get install i2c-tools
sudo i2cdetect -y 1
Для осуществления доступа к I2C нужно подключить библиотеку smbus.
SPIподдерживают 11 выводов общего назначения. С помощью этого интерфейса можно настроить подключение нескольких устройств с помощью одной группы контактов.
Для работы понадобятся плата Raspberry Pi, светодиод, резистор на 200 Ом и соединительные провода. Анод светодиода (длинная ножка) нужно подключить через резистор к одному из цифровых выводов, например GPIO24, катод (короткая ножка) – к земле. Макет подключения представлен на рисунке. Резистор в данной схеме нужен для того, чтобы уберечь светодиод от перегорания. Выбрать правильный номинал можно пользуясь законом Ома R=U/I. Плата работает от напряжения 3,3В. Номинал, который будет получен по формуле – минимальный, можно выбирать сопротивление больше, но в этом случае яркость светодиода будет несколько ниже.
Теперь нужно написать программу. Код будет написан в установленной версии Python 2. Для этого нужно открыть среду Python 2 (IDLE) и нажать «новый файл».
В окно редактора нужно написать скетч, который заставит светодиод загореться на 10 секунд и отключит его. В первую очередь нужно выбрать нумерацию выходов. Как говорилось выше, существует несколько типов нумерации. В данном случае будет использоваться нумерация BCM.
Сам код выглядит следующим образом:
[py]from RPi import GPIO
from time import sleep //первые 2 строки включают библиотеки для совместной работы с GPIO и sleep
GPIO.setmode(GPIO.BCM) //этой строкой выбирается нумерация контактов
GPIO.setup(24, GPIO.OUT) //чтобы управлять светодиодом или другим устройством, нужно задать OUT. Для того чтобы считывать сигнал сенсора, нужно ввести IN.
GPIO.output(24, True) //подача истины на контакты
sleep(10) //светодиод загорается на 10 секунд, ожидание
GPIO.output(24, False)
GPIO.cleanup() //сброс всех настроек портов, чтобы они не мешали следующей программе.
[/py]Нужно нажать запуск программы с помощью F5 или меню Run/Run Module.
Код можно немного изменить, чтобы светодиод включался и выключался с определенной частотой. Для этого нужно добавить оператор while вместо строк GPIO.output и Sleep.В цикле нужно задать частоту, с которой будет мигать светодиод. В данном случае он будет мигать раз в 1 секунду.
[py]while True:
GPIO.output(24, True)
sleep(1)
GPIO.output(24, False)
sleep(1)
[/py]Большим недостатком такой программы будет то, что она будет повторяться бесконечно и остановить штатным методом ее будет невозможно. Для этого нужно ввести дополнительно конструкцию, прерывающую работу при наборе на клавиатуре комбинации Ctrl+C.
[py]try:
while True:
GPIO.output(24, True)
sleep(0.5)
GPIO.output(24, False)
sleep(0.5)
except KeyboardInterrupt:
print ‘program stop’
[/py]Программу нужно сохранить, нажав ctrl+S. Затем нужно нажать F5, светодиод начнет мигать с периодичностью раз в секунду. Чтобы остановить выполнение программы, нужно нажать ctrl+C.
В этой статье мы приступили к новой большой теме и сделали первые шаги в программировании на Python под Raspberry с использование GPIO. Возможности микроконтроллера существенно превышают привычный Arduino, поэтому для создания по-настоящему умных устройств придется осваиваться с новыми инструментами для работы с периферией. В дальнейших статьях мы продолжим наши эксперименты.
arduinomaster.ru