GPIO-пины Raspberry Pi и их использование из Python. Установка и настройка Python и библиотек на Raspberry Pi Raspberry pi 3 gpio программирование c
Программирование Raspberry Pi 3 - это как раз то, для чего большинство людей и берет этот одноплатный компьютер. Здесь сразу же следует отметить, что в этом материале не будет изложено инструкций, подробно раскрывающих, как и что нужно делать - таких в «сети» полно. Однако, рекомендуется читать официальную документацию и специализированные формы. Вместо этого в статье будут рассмотрены основные моменты, из которых станет понятно, что на Raspberry Pi программирование не отличается сложностью.
Python - это основной язык Raspberry Pi
Почти все владельцы Raspberry Pi понимают, что означает первое слово в названии одноплатника - "малина". Однако второе многие интерпретируют неверно.
Некоторые считают, что оно означает "Пи" (3,14…), другие думают, что это первые две буквы слова Pie (пирог, и в этом есть смысл - "малиновый пирог"). Однако на деле все иначе.
Pi - это сокращение от Python, только с заменой y на i. Так часто делают в программировании. Взять, например, хотя бы KDE, где во многих программах вместо С написано K (в угоду стилю): Konsole (правильно - Console), Konqueror (Conqueror) и т. д.
То есть, как не трудно догадаться, в Raspberry основным языком является "Пайтон". Поэтому владельцу "Малины", который пока не знает никакого ЯП, рекомендуется изучать именно этот. Причин, почему Raspberry Pi 3 программирование на Python наиболее лучшее решение, существует множество.
Вот лишь некоторые из них:
- работа из коробки в Raspbian;
- наличие обширной, хорошо документированной официальной библиотеки, которая уже включена в пакет;
- простота языка и т. д.
Здесь по понятным причинам не будем рассказывать о языке и особенностях программирования на нем - это можно и нужно делать на официальных ресурсах (или, если не позволяет плохое знание английского - на специализированных).
Вместо этого будет рассмотрено, насколько легко можно программировать "Малину". Для примера возьмем Raspberry Pi 3 GPIO программирование. Сделаем предположение, что в наличии имеется все необходимое: провода, светодиод, резистор и прочее, а также присутствует понимание распиновки - нумерации пинов. Также предположим, что светодиод подключен к 11 порту.
Написанный ниже код включает лампочку на 5 секунд, а затем выключает ее:
# вначале подключим необходимую библиотеку
import RPi.GPIO as GPIO
# также понадобится библиотека, которая отвечает за ожидание (она нужна, чтобы установить интервал включения и выключения лампочки)
# чтобы запустить GPIO, понадобится выполнить следующую функцию
GPIO.setmode(GPIO.BOARD)
# теперь Python знает о GPIO, и ему можно указать на то, с каким портом нужно будет работать и что он должен делать (в данном случае - 11-м и он будет работать на выход)
GPIO.output(11, 1)
# теперь выключим (0 - значит false)
GPIO.output(11, 0)
Указанный код можно скопировать, вставить в документ и сохранить его с расширением.py, расположив, например, в домашней директории. Затем его нужно запустить командой: python ~./имя_файла.py.
Если все работает, то оборудование исправно.
Следует отметить, что, если вы плохо понимаете вышеуказанный код, обратитесь к документации и изучите основы программирования на Python, а также библиотеку GPIO. А если у вас есть хотя бы базовое понимание любого ЯП, то осознаете, что приведенный пример предельно прост.
Программирование на других языках под Raspberry
Программирование на C для Raspberry Pi или на других языках программирования почти ничем не отличается от того, что предполагает написание кода под другими платформами. Единственное - необходимы специальные библиотеки.
Библиотека WiringPi для работы с GPIO
Если интересует Raspberry Pi программирование на C/С++ и работа с GPIO, то требуется установить в систему непосредственно сам gcc, а затем библиотеку wiringPi - ее можно найти на GitHub. В описании к ней присутствует мануал по использованию.
Следует отметить, что для установки библиотек из GitHub, требуется утилита GIT. Если в системе ее нет, понадобится поставить из репозитория (полное имя: git-core).
Программирование "Малины" при помощи Java
Желающие программировать Raspberry Pi на Java, должны обратить внимание на Pi4J - библиотеку, которая предназначена специально для работы с "Малиной". Загрузить и узнать о ее особенностях можно на официальном сайте проекта.
Интересно то, что изначально "Малина" разрабатывалась непосредственно для обучения детей программированию. Создатель этого устройства заметил, что уровень понимания функционирования компьютеров у современных студентов значительно ниже, чем у тех, кто учился в 90-х. Он связал это с тем, что вычислительные устройства стали предельно просты: если раньше увлеченным электроникой детям и подросткам приходилось разбираться в командах терминала и даже самостоятельно писать код, теперь все делается посредством нажатия на пару кнопок.
Поэтому, естественно, предусмотрено визуальное программирование Raspberry Pi. В частности, для этого применяется язык Scratch со специальным сервером - GPIOSERVER. В Сети существует множество мануалов, которые помогают освоиться с соответствующими программами, поэтому рассматривать их смысла нет.
Перечисленными языками не ограничиваются возможности "Малинки". С ней можно взаимодействовать в том числе и при помощи PHP, Ruby, Perl и прочих ЯП. Почти под каждый популярный язык существуют хоть и не официальные, но зато рабочие и достаточно функциональные библиотеки. Однако опять следует упомянуть, что лучше для программирования Raspberry использовать именно "Пайтон".
В 2011 году одноплатный компьютер Raspberry Pi был выпущен для тех, кто устал искать готовые решения и решил творить технологическое окружение самостоятельно. В то время как Arduino – это игрушка в большей степени для любителей работать руками, «малиновый» продукт – разминка мозга для программистов.
Всего за 6 лет под Raspberry были адаптированы почти все популярные языки программирования. Какие-то имеют существенные ограничения, какие-то работают на полную катушку. Рассмотрим 9 представителей второй категории.
Scratch
Официальный сайт предлагает пользователям Raspberry первый делом обратиться к Scratch. Исходники языка уже включены в стандартную операционную систему Raspbian. Начать создание IoT с помощью Scratch может как взрослый специалист, так и совсем ещё ребёнок. Недаром он всего за 10 лет выбился в топ-20 языков по числу запросов в поисковиках.
Python
Возможно для вас это будет сюрпризом, но Pi в названии – это не математическая константа, а отсылка к Python. IDLE, стандартная среда разработки программ на Raspberry, работает как раз на змеином языке. На официальном сайте в разделе документация вы найдёте базовое руководство . Кроме того, благодаря Python Games и их исходникам, вы познакомитесь с возможностями языка.
HTML5 и CSS3
Компьютеры Raspberry Pi подходят для создания систем IoT, а встроенный браузер Epiphany - подходящий клиентский интерфейс. Это значит, что без языков веба не обойтись. HTML5 и CSS3 позволят вам решить вопрос создания виртуальной оболочки умного дома с минимальными затратами времени и незначительными ограничениями.
JavaScript
JavaScript - динамическая сила Raspberry Pi. Вы сможете поработать с ним благодаря платформе Node.js, позволяющей вам создавать десктопные и веб-приложения. Не стоит забывать про библиотеку jQuery, которая работает в любом браузере, и наполняет его привычными динамическими функциями.
Java
Возможность запустить Java-код на любой платформе – главная концепция языка. И эта концепция особенно полезна для таких платформ, как Raspberry Pi. Вы сначала отладите код на «большой» ОС, а потом перенесёте на Raspbian. При этом разработка приложений на Java внутри «малиновой» системы затруднительна - здесь нет полноценной среды для этого языка.
С
Так как Raspbian – ОС на базе Unix, в качестве базового языка здесь выступает С. С его помощью вы получите максимальную производительность без использования машинных команд. Это особенно важно для серверных систем в составе IoT. Надмножество языка, Objective-C, используется для написания приложений для iPhone и iPad, что также может пригодиться вам с «малиной».
C++
С++ пригодится там, где нужны и скорость, и безопасность, и чёткость работы. Спектр задач при этом невероятно широк – от работы непосредственно с железом до организации взаимодействия устройств и клиентов. С++ переменит на «малиновую» сторону опытных разработчиков из прошлого века и тех, кто до этого писал код лишь для микроконтроллеров.
Perl
Perl постепенно сдаёт позиции в мире больших машин, но в Raspberry Pi это пока один из основных инструментов. Он поставляется «из коробки», имеет множество расширений и дополнений, с его помощью можно организовать сбор информации или переписать Си-программу. Это ударит по быстродействию, зато работать с таким кодом на порядок проще.
Erlang
Erlang - язык программирования для создания сложных систем. Допустим вы разрабатываете на своем одноплатном друге атомную электростанцию или нейронно-вычислительную сеть. C++ или другой прикладной язык не подойдёт. А вот Erlang позволит вам минимизировать ошибки и извлечь максимум возможностей из Raspberry Pi. Конечно, если вы дорастете до этого уровня.
Как вы поняли, язык разработки для Rasberry Pi имеет третьестепенное значение. Выбор зависит от вкусовых предпочтений, от типа решаемой задачи и вашего опыта. А значит, Rasberry Pi станет вашим верным спутником в программировании, какой бы путь вы ни выбрали.
Что делать, когда нечего делать?
Попробовать что-нибудь новое!
Если вы приобрели Raspberry Pi просто ради любопытства, не отдавая себе отчёта в том, для чего он конкретно вам нужен, то наверняка с каждым днём вам становится всё труднее найти для него
применение. Вы уже с ним вдоволь наигрались. Попробовали установку разных операционных систем, послушали музыку, посмотрели видео, попробовали поиграть и порисовать… И наверняка с огорчением для себя сделали вывод - «Всё ж таки Raspberry Pi мало годится для использования в качестве настольного компьютера». Слишком он уж медленный и задумчивый, по сравнению с обычным компьютером. И вроде бы ничего серьезного с ним сделать нельзя. Остаётся лишь найти ему применение в качестве либо медиацентра, либо простенького интернет-сервера, который не страшно
оставлять включённым круглые сутки…
Но всё ж таки Raspberry Pi может делать одну вещь гораздо более эффективнее, чем любой домашний компьютер- он может управлять внешними устройствами. Устройства могут быть абсолютно любыми, от обычной лампочки, до беспилотного летательного аппарата. В данном случае, область применения Raspberry ограничена лишь вашей фантазией и знаниями. И если вы никогда и ничего подобного не делали, но это вас заинтересовало, то эта статья для вас. И так, начнём.
Чтобы общаться с любыми внешними устройствами и управлять ими, Raspberry Pi имеет на борту интерфейс, называемый GPIO
. Это аббревиатура от General Purpose Input Output
. А по-русски, это низкоуровневый интерфейс ввода-вывода прямого управления. На плате Raspberry он находится в углу, в виде гребёнки из 26 штырьков, рядом с видеовыходом. Т.е.
через этот интерфейс Raspberry может слушать и отдавать команды любому внешнему устройству, например беспилотнику. Но сегодня мы беспилотник строить не будем, начнём с обычной лампочки, а точнее светодиода, который и исполнит роль подопытной лампочки. Наша задача- заставить светодиод, подключённый к Raspberry включаться и выключаться по его команде. Кроме того, дабы убедиться, что эти включения происходят вполне осознано и так, как мы этого хотим, а не благодаря каким-то глюкам в недрах процессора, мы привнесём в нашу программу элемент
общения с нами. Т.е. отстроим чёткую иерархию- Raspberry управляет светодиодом,
а самим Raspberry управляем мы. Теперь надо подготовиться и раздобыть где-то
несколько вещей.
Во-первых, нужно найти светодиод
:
Его можно достать из старой сломанной игрушки, из зажигалки с фонариком, попросить у знакомого радиоэлектронщика, в конце концов, просто купить.
Во-вторых, понадобятся проводочки любые и парочка коннекторов BLS
:
Такие коннекторы можно вытащить из старого системного блока вместе с проводами, или попросить у знакомого компьютерщика, или тоже купить. Они прекрасно подходят для подключения к разъёму на Raspberry.
Начнём с планирования используемых портов. Порт- это грубо говоря штырёк на разъёме. Так, как штырьков там много (26), то и портов тоже много. А чтобы в них не
запутаться, то каждому порту присвоен свой номер и обозначение. Следует заметить, что не все штырьки в этом разъёме являются портами. Некоторые штырьки
подключены к источникам напряжения, а некоторые вообще никуда не подключены (По секрету, на самом деле они всё-же подключены, но ими пользоваться нельзя, можно
убить свою Малинку. Поэтому лучше вобще их не трогайте).
Вот собственно как
эти порты расположены на плате:
Чтобы светодиод зажёгся, нам нужно его подключить к источнику питания. Выбираем для питания светодиода Р1-01
, верхний по рисунку штырёк, на котором присутствует
напряжение 3,3в. Для управления светодиодом нам понадобится один порт GPIO. Можно выбрать любой. Но если у вас есть разъём BLS, то удобнее в данном случае использовать порт, который выведен на штырёк P1-03
и называется GPIO 0
. В таком случае мы, воспользовавшись одним разъёмом, сможем подключить наш светодиод. И так, мы будем подключать светодиод между ножками разъёма P1-01
и Р1-03
. С вывода Р1-01
мы берём +3,3в для питания светодиода, а вывод Р1-03
будет тем самым управляющим выводом порта GPIO. Все эти порты физически находятся внутри центрального процессора Raspberry Pi, который называется BCM2835. Этот процессор может подключать любой порт к источнику напряжения 3,3в, а может подключить порт к 0 питания (а может вообще никуда не подключать, но об этом позже). Эти переключения он делает в соответствии с поданной командой. Значит, когда порт будет подключён к напряжению +3,3в, наш светодиод гореть не будет, т.к. току некуда идти. А когда процессор подключит порт к 0, то наш светодиод загорится, т.к. ток побежит от +3,3в к 0 через светодиод. Значит наша программа должна будет отдавать соответствующие команды процессору в соответствии с нашим желанием.
Маленькое, но важное
отступление.
На самом деле, мы не должны подключать светодиод напрямую между источником питания +3,3в и выводом порта. Это нельзя делать по двум причинам. Причина первая: любой светодиод нормально работает при определённом токе. Если через светодиод потечёт большой ток (а выход +3,3в способен отдать до 50мА), то светодиод сгорит. Если маленький ток, то светодиод будет гореть слишком слабо, либо вообще не будет светиться. Для большинства обычных светодиодов рабочий ток находится в пределах 10-20мА. Отсюда вытекает и вторая причина (хотя в данном случае она несущественна). Если мы пропустим большой ток через порт GPIO, то этим самым мы уничтожим процессор и Raspberry- умрёт. Поэтому, мы должны следить, чтобы через порт не протекал ток больше допустимого. Примем для себя ограничение в 16мА, так мы точно не сожжем процессор. Как этого добиться? Очень просто! Нам нужно последовательно со светодиодом
включить токоограничивающий резистор. И сейчас мы его рассчитаем.
Примем для светодиода рабочий ток в 10мА. Убеждаемся в том, что выбранный нами ток не превышает предельно допустимый ток для порта в 16мА. Теперь зная напряжение питания 3,3в и рабочий ток 10мА, мы можем по закону Ома рассчитать необходимое нам сопротивление. R=U/I=3,3/0,01=330Ом
. Значит нам нужно найти резистор с сопротивлением 330Ом. А точнее- сопротивлением не менее 330Ом. Больше- можно. Светодиод будет заметно светиться и при сопротивлении 1000 Ом, или 1кОм. В общем наша задача- найти резистор с
сопротивлением от 330 Ом до 1кОм. Если вы его нашли, то можно собрать вот такую схему:
Схему лучше собрать на макетной плате. Лично мне, для экспериментов, мой сын дал на прокат свой конструктор «Знаток».
Так выглядит схема в сборе:
Так мы подключаемся к Raspberry:
А вот общий план всей конструкции:
В крайнем случае, можно просто скрутить выводы элементов. Но в этом случае нужно следить за тем, чтобы оголённые ножки элементов случайно не попали на контактные площадки Raspberry. Это может убить его. Так же стоит обратить внимание на то, что светодиод должен подключаться Анодом
к + источника питания, т.е. в нашем случае это Р1-01
. Как найти на светодиоде Анод? Очень просто! Достаньте из любого ДУ батарейку на 1,5В и подключите к ней ваш светодиод. Если он не зажёгся, поменяйте выводы местами. Если зажёгся- то на + батарейки и будет Анод светодиода.
Если вы собрали схему, то отложите пока её в сторонку. Теперь мы займёмся второй частью задачи - написанием программы управления светодиодом. Писать эту программу мы будем на языке Си.
Почему на именно на Си? Просто по тому, что я других языков не знаю, а раз вы читаете эту статью, то скорее всего вы тоже немного знаете о программировании и радиоэлектронике, а значит, вам всё равно с какого языка начинать.
Обычно изучение языков программирования начинают с написания программы «Hello World!», но мы же круче «тех» чайников, поэтому мы начнём сразу с низкоуровневой работы с периферией. Тем более, что это не намного сложнее ХеллоуВорлда. ;) Что для этого нужно? Нужен любой текстовый редактор, в котором мы будем набирать программу. В Raspbian есть отлично подходящий для этого редактор “nano
”. Ещё нужен компилятор, это программа, которая осуществляет перевод написанной нами программы с человечески понятного языка на язык, понятный компьютеру. Т.е. делает из нашей программы исполняемый файл, который мы впоследствии и запустим на Raspberry. Эта штука тоже у нас есть, называется gcc
. Этот компилятор поставляется в комплекте со всеми Линуксами и уже готов к работе.
Как видите,всё необходимое у нас уже есть. Хотя нет. Одной вещи все-таки у нас не хватает. Её мы возьмем из интернета. Речь идёт о библиотеке функций управления портами GPIO на Raspberry, специально написанно добрым человеком для того, чтобы наша программа по своей простоте могла бы соперничать с «Хеллоуворлдом» и нам самим бы не пришлось ломать голову, изучая техническую документацию на процессор и протоколы работы с его внутренностями. Сама библиотека состоит из заголовочного файла, в котором обозначены все имена функций со структурами переменных и файла библиотеки самих функций. Эту библиотеку нужно скачать и установить, чтобы компилятор мог с ней работать. Библиотека называется bcm2835-1.17
. Последние цифры в названии библиотеки, обозначают её версию. А так, как библиотека постоянно обновляется автором, то версии будут меняться. на сегодняшний день доступна версия 1.17. Узнать о номере последней версии можно по адресу: http://www.open.com.au/mikem/bcm2835/index.html
По этой же ссылке вы можете ознакомиться со всеми функциями, которые присутствуют в этой библиотеке.
Мы же пока установим версию 1.17. Запускаем окно терминала и вводим
туда команду:
wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.17.tar.gz
Библиотека быстренько скачивается. Чтобы её установить, нужно сначала её разархивировать. Это делается следующей командой:
tar zxvf bcm2835-1.17.tar.gz
Теперь перейдём в директорию, куда эта библиотека развернулась:
cd bcm2835-1.17
Ну и инсталлируем её:
./configure make
sudo make check
sudo make install
Всё, теперь эта библиотека у нас есть в наличии, она установлена, и мы, и компилятор можем ей пользоваться в своих интересах. Начинаем писать программу. Возвращаемся в домашнюю директорию:cd ..
Тут можно создать папочку для наших экспериментов с любым именем, например myprog:
mkdir myprog
Перейдём в эту папку:
cd myprog
И начинаем писать нашу программу:nanoGPIO-test.c
Эта команда запускает текстовый редактор nano
, который создаёт текстовый файл GPIO-test.c
.Теперь можете набрать в нём следующую программу
(можно просто скопировать и вставить):
//GPIO-test.c
// Программа включает на 1 секунду светодиод,
// подключённый к порту Р1_03
// Компиляция командой gcc -o GPIO-test GPIO-test.c -lrt -lbcm2835
#include
#define PIN RPI_GPIO_P1_03 // Для RPi ревизии v1
//#define PIN RPI_V2_GPIO_P1_03 // Для RPi ревизии v2
Int main()
{
if (!bcm2835_init()) // Инициализация GPIO
return 1; //Завершение программы, если инициализация не удалась
Bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP); //Устанавливаем порт Р1_03 на вывод
bcm2835_gpio_write(PIN, LOW); // Устанавливаем порт в 0, светодиод горит
bcm2835_delay(1000); // Ждём 1000 милисекунд
bcm2835_gpio_write(PIN, HIGH); // Устанавливаем порт в 1, светодиод не горит
return 0; // Выход из программы
}
Обратите внимание на строки #define. Их в программе 2 и одна из них закомментирована. Одна строка для ревизии RPi v1, вторая для RPi v2.
Если у вас v1, то всё оставьте как есть. Если у вас RPi v2, то первую строку с #define удалите, а со второй уберите символ комментария //.
В будущем, во всех остальных программах, просто добавляйте _V2_ между RPI и GPIO в определении портов, если ваша плата RPi v2.
Сохраняем нашу программу ctrl-o
и выходим из текстового редактора ctrl-x
. Теперь, если вы введёте команду ls
, то увидите только что созданный файл GPIO-test.c. Чтобы этот файл превратился в работающую программу, его нужно скомпилировать. Пишем: gcc -o GPIO-test GPIO-test.c -lrt -lbcm2835
в этой строке: gcc- это имя компилятора; -o GPIO-test GPIO-test.c эта команда компилятору говорит о том, что требуется создать исполняемый файл с именем GPIO-test из текстового файла GPIO-test.c; -l (латинская л маленькая) bcm2835 говорит компилятору о том, что все неизвестные ему функции в нашей программе, он может найти в установленной библиотеке bcm2835. Если компилятор не выдал никаких сообщений, то значит, всё у нас получилось. Если сейчас дать команду ls
, то мы увидим, что в директории появился ещё один файл GPIO-test, причём он отмечен зелёным цветом. Это говорит о том, что файл является
исполняемой программой. Осталось нам его запустить, но перед этим ещё раз проверяем нашу схему со светодиодом, чтобы всё было собрано правильно и подключено к контактам Р1_01
и Р1_03
разъёма GPIO. Если ошибок не обнаружено, запускаем программу: sudo ./GPIO-test
После этого светодиод должен загореться
ровно на 1 секунду и погаснуть. Если всё так и произошло, то я вас поздравляю! Вы только что при помощи Raspberry Pi передали через порт GPIO команды светодиоду: включиться, гореть 1 секунду и выключиться.
Теперь о том, что делает каждая строка в нашей программе.
Все надписи после двойного слеша // являются коментариями и никак не влияют на выполнение программы.
#include
>#define PIN RPI_GPIO_P1_03 - здесь мы говорим компилятору, что везде в программе, где он увидит идентификатор PIN, ему нужно выполнить замену его на идентификатор RPI_GPIO_P1_03 . Это сделано для того, чтобы мы могли при желании быстро изменить номер подключаемого порта. Для этого достаточно изменить только эту строку, а не выискивать по всей программе, где мы этот идентификатор использовали.
int main() это начало нашей программы, обозначение главной функции в Си.
if (!bcm2835_init())
- эта часть пытается инициализировать GPIO и если это не получилось,
return 1;
то аварийно завершает программу и передаёт на выходе код 1.
bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);
- Эта функция устанавливает для нашего порта Р1_03 режим на вывод. Т.е. говорит процессору, что этот порт будет использован для управления внешним устройством.
bcm2835_gpio_write(PIN, LOW);
- устанавливаем порт Р1_03 в низкое состояние, т.е. процессор его подключает к 0. После этого светодиод загорается.
bcm2835_delay(1000); - Эта функция просто ждёт 1000 милисекунд, или ровно 1 секунду. Всё это время у нас горит светодиод.
bcm2835_gpio_write(PIN, HIGH); - устанавливаем порт Р1_03 в высокое состояние, т.е. процессор его подключает к +3,3в. При этом светодиод гаснет.
B>return 0; - Выход из программы с кодом 0.
Т.е. алгоритм работы с портом GPIO в режиме записи, т.е. вывода, выглядит следующим образом:
1. Инициализируем GPIO;2. Устанавливаем режим для выбранного порта на Вывод;
3. Теперь можем управлять этим портом, устанавливая его в высокое, или низкое состояние. Соответственно на этом порте будет пристутствовать либо +3,3В, либо 0В. Что соответствует логической 1 и логическому 0 соответственно.
На этом на сегодня закончим. В следующей части научим наш светодиод загораться более полезным образом, а так же научимся портами GPIO не только отдавать команды другим устройством, но и слушать их.А пока можете начинать изучать язык Си. А так же попробуйте изменить эту программу так, чтобы светдиод управлялся бы другим портом и испытайте её.
RPi - компьютер, который получил столь высокую популярность во многом благодаря наличию встроенного интерфейса ввода/вывода. Используя его, можно создавать всевозможные гаджеты: от простых метеостанций и портативных игровых приставок до систем умного дома. У Raspberry Pi 3, конечно, тоже имеется GPIO. И он мало чем отличается от тех, который присутствует в других моделях.
Чтобы работать с GPIO Raspberry Pi 3, необходимо знать его схему. Собственно, это является самым важным. Из текста ниже, в свою очередь, вы узнаете о том, какие пины за что отвечают. А, чтобы иметь лучшее представление об устройстве GPIO, рекомендуется скачать соответствующую схему, выполненную в графике.
Что такое GPIO и для чего он нужен?
Новичкам будет полезно узнать о том, что собой представляет GPIO. Это интерфейс, который предназначен для обеспечения связи между компонентами компьютера. В случае с "Малиной" он необходим для работы основной системы с дополнительными компонентами, которые называются модулями.
Пины в GPIO могут выполнять 3 функции:
- подача электричества определенного напряжения;
- заземление;
- прием/отправка сигналов.
Интересно то, что за вход и выход в интерфейсе могут отвечать одни и те же контакты. По крайней мере это справедливо для RPi. То, как они себя должны вести, определяется программой.
Как устроено GPIO на RPi3?
Теперь можно перейти к вопросу, который касается того, какая распиновка GPIO имеется на Raspberry Pi 3. В первую очередь необходимо сказать, что общее количество пинов на соответствующей панели равняется 40. Каждый из них имеет свой номер.
Все они подразделяются на 3 группы. К первой относятся питающие (на англоязычных схемах маркируются как Power) - они подают электричество в 3,3 и 5 Вольт. При этом у разных контактов данного назначения различное напряжение. Это обязательно следует учитывать при подключении модулей.
Ко второй - заземляющие (могут именоваться RND или Ground). Они нужны, чтобы отводить электричество, тем самым обеспечивая безопасное использование.
К третьей - порты (имеют обозначение BCM). Именно они служат теми контактами, которые могут принимать и отправлять сигналы. Пользователь может подключать модули к любым из них. Самое главное - чтобы было удобно обеспечивать питание подсоединённых компонентов.
Разобравшись с тем, какие типы контактов присутствуют в GPIO, можно перейти непосредственно к тому, какие из них конкретно за что отвечают. Самый простой способ освоить распиновку - это изучить схему. Но если такой возможности нет, можно обойтись и описанием.
Предположим, что плата расположена горизонтально таким образом, что GPIO на ней находится в левом верхнем углу. В таком случае номера портов будут располагаться так:
- левый нижний - 1;
- левый верхний - 2;
- нижний во втором ряду - 3;
- верхний во втором ряду - 4 и т.д.
Из списка выше должно быть понятно, по какому принципу выполнена нумерация соответствующего интерфейса. Теперь можно перейти к тому, контакты под какими номерами имеют какое назначение.
Питающие на 3,3 Вольта - 1 и 17, а на 5 Вольт - 2 и 4 (они находятся рядом). Заземляющие внизу - 9, 25 и 39, заземляющие вверху - 6, 14, 20, 30 и 34. Все остальные контакты - это порты (BCM).
Особенности нумерации GPIO
Чтобы начать использование GPIO в Raspberry Pi 3, необходимо знать какие существуют особенности нумерации контактов у данного интерфейса. Важно понимать, что в процессоре "Малины" не записаны номера пинов, которые не работают на вход/выход, то есть не являются портами.
Поэтому при управлении GPIO на Raspberry Pi 3 необходимо знать нумерацию BCM. Она в значительной степени отличается от той, которая рассмотрена в разделе выше. Так, 3 контакт (он является портом) имеет номер BCM2. Именно такой следует указывать при написании кода.
Понятно, что из-за этого может возникнуть путаница. Ввиду этого на Raspberry Pi 3 рекомендуется использовать Wiring Pi. Это специальная библиотека, которая имеет собственную нумерацию. Так, например, 3 порт (который является BCM 2) определяется как WiringPi 8. Возможно, это покажется еще более нелогичным. Но после ознакомления с соответствующей схемой все встанет на свои места.
Что нужно знать о GPIO RPI3?
Модули возможно подключать к абсолютно любым портам GPIO "Малины", и они будут нормально работать. Но важно знать, что в системе есть пара контактов, которые зарезервированы системой для особых целей. Ими являются BCM 0 и BCM 1 (их номера на обычной схеме - 27 и 28). Они предназначаются специально для установки плат расширения. Поэтому при возможности их не нужно использовать для подключения других модулей.
Еще один важный момент - осторожное использование питания через GPIO Raspberry Pi 3. Ток на внешние устройства через "Малину" может подаваться с силой до 50 мА. Это достаточно много для столь небольшого девайса. Поэтому подавать ток под такой силой нужно только по крайней необходимости. В противном случае можно не только испортить модуль, но и процессор самой RPi.
Как можно взаимодействовать с GPIO?
Работать с GPIO "Малины" можно посредством языков программирования. Вариантов здесь существует много. Самый лучший для GPIO Raspberry Pi 3 - Python. Это связано с тем, что для этого одноплатника данный ЯП является "родным". Но с не меньшим успехом с интерфейсом возможно взаимодействовать и посредством C/C++ и даже PHP или Basic. Язык каждый выбирает под себя.
Как возможно убедиться, распиновка GPIO на RPi3 не является какой-то сложной. Единственное - по неопытности в ней можно немного запутаться. Чтобы этого не происходило, рекомендуется загрузить на компьютер схему расположения контактов. При этом лучше не одну, а несколько (обычную, BCM и WiringPi). Так будет удобно и подключать модули, и взаимодействовать с ними через программные инструменты.
Raspberry Pi - одноплатный компьютер размером 55 × 85 мм.
Изначально проект создавался как образовательный. Raspberry Pi отлично подходит для изучения основ программирования и электроники из-за небольшой стоимости (порядка $35) и наличия практически всех необходимых признаков настоящего компьютера. На основе Raspberry Pi создано множество компьютерных классов. Однако сегодня его назначение вышло далеко за пределы образовательного. Устройство широко используется для создания различных электронных устройств от радиоприемников и медиаплееров до роботов и «умных домов».
Самая мощная на сегодня модель Raspberry Pi 3 Model B имеет разъём HDMI для подключения монитора, 4 USB-порта для подключения USB устройств, Ethernet-порт для подключения к сети, встроенный Wi-Fi и Bluetooth, 4 ядерный 64-битный процессор ARM 1.2 ГГц, 1 ГБ оперативной памяти. В отличие от обычных компьютеров на маленькой плате Raspberry есть 40 контактов (пинов) GPIO, который могут использоваться как на вход, так и на выход с применением различных протоколов взаимодействия с внешними устройствами, что и позволяет подсоединять к плате различные датчики и исполнительные приборы.
1. Внешний вид, основные элементы, корпус.
Итак, в наших руках Raspberry Pi 3 Model B.
Верхняя сторона выглядит так:
Нижняя сторона:
На нижней стороне установлены слот для SD-карты и оперативная память. SD-карта служит постоянным запоминающим устройством и содержит файлы операционной системы, программ и файлы пользователя.
Для удобства обращения с платой предлагается множество различных корпусов, а вот детали одного из них, они соединяются между собой без винтов:
Но сначала на процессор и графический чип стоит установить радиаторы, поскольку эти микросхемы прилично греются при активной работе платы:
Вот теперь можно собрать корпус и пометить туда плату микрокомпьютера:
 |
 |
 |
Корпус имеет открывающуюся крышку для удобного подключения камеры, дисплея и контактов GPIO.
2. Подготовка к включению и первый запуск.
Для первого запуска Raspberry необходимо следующее:
- микро SD-карта с установленной операционной системой (OC) Raspbian, рекомендуемой для этого устройства (оптимальная емкость карты - 8 Гб, класс скорости - 10);
- монитор с HDMI входом;
- сетевой блок питания с выходным напряжением 5 В и током не менее 2 А, с выходным разъемом micro-USB;
- USB-мышь и USB-клавитура.
Образ операционной системы Raspbian, созданной на основе Linux Debian 8 Jessi, можно скачать в разделе Downloads сайта raspberrypi.org. Для начала можно воспользоваться образом RASPBIAN JESSIE LITE, как наиболее простым в изучении. Записать образ на SD-карту удобно из-под Windows с помощью программы Win32DiskImager. Способ установки и сама программа описаны на сайте Raspberry по адресу.
Вы также можете воспользоваться файлами, размещенными на нашем сайте в карточке Raspberry Pi 3 или напрямую скачать с Яндекс диска:
- образ операционной системы;
- программа Win32DiskImager.
Дальнейшее описание базируется именно на этом образе.
Мышь и клавиатура, подключенные к Raspberry без проблем распознаются системой. Можно также использовать беспроводную мышь и клавиатуру, например Bluetooth, но их надо настроить после запуска Raspberry, а для этого нужна хотя бы USB-мышь. У нас в хозяйстве не нашлось USB-клавиатуры, поэтому для первого запуска мы подключили USB-мышь, а также монитор и питание:
Кстати, на плате нет выключателя питания, она запускается сразу при подключении разъема, и начинается загрузка операционной системы. После загрузки на экране появляется рабочий стол с вполне привычными (но оригинальными) обоями и иконками:
На начальном экране имеются легко распознаваемые иконки Меню, интернет-браузера, менеджера Bluetooth, регулятора громкости, настройки сети и некоторые другие. Из них, пожалуй, самая нужная при настройке и работе - это черный экранчик в правой верхнем углу: терминал. С помощью терминала вводятся команды операционной системы. Поскольку далеко не все программы для Linux имеют графический интерфейс, их можно запустить и работать в них только посредством командной строки. Именно эту возможность и предоставляет терминал. Также все системные операции Linux, например установка и удаление программ осуществляются преимущественно через терминал. В OC используется программа LXTerminal, которая и запускается при щелчке правой кнопкой мыши по иконке. Следует заметить, что многие команды требуют ввода в начале строки приставку sudo (gksudo при запуске программ с графическим интерфейсом), что позволяет выполнить команду от лица администратора компьютера, то есть с наивысшими правами (sudo - Super User Do). Только администратор может устанавливать и удалять программы, а также менять параметры OC и ее конфигурацию.
После первой загрузки системы имеет смысл сразу подключиться к интернету, чтобы обновить файлы ОС до актуальной версии. В правом верхнем углу рабочего стола есть иконка с узнаваемым изображением двух терминалов. При подключении кабеля к разъему Ethernet на плате Raspberry происходит автоматическое подключение к локальной сети. Если щелкнуть мышью по этой иконке, появляется список беспроводных сетей, из которых можно выбрать свою и подключиться к ней, введя соответствующий ключ. При этом вместо терминалов на иконке появится стандартное изображение подключение к беспроводной сети. Именно такая ситуация показана на рисунке выше.
Надо сказать, что по сравнению с ранними версиями Linux многие задачи сейчас автоматизированы. Например, если ранее было необходимо из командной строки монтировать том при подключении обычной флешки, то сейчас флешка распознается при подключении в один из четырех разъемов USB на плате вполне самостоятельно и ей сразу можно пользоваться.
Теперь можно подключить, например, беспроводные мышь и клавиатуру по Bluetooth:
Это делается щелчком на иконке с логотипом Голубого Зуба рядом с индикатором подключение к сети в правом верхнем углу экрана. Далее надо нажать Add Device и выбрать ваши устройства из списка найденных беспроводных устройств.
Следует отметить, что при всем удобстве использовании Bluetooth устройств ввода с Raspberry - они не занимают разъемов USB - эти устройства в нашем случае периодически теряли связь с платой. Поэтому для стабильной работы, все же следует использовать USB-мышь и клавиатуру, а так же, в качестве альтернативного варианта, занимающего только один USB-разъем, комплект мыши и клавиатуры с одним приемопередатчиком по радиоканалу.
После соединения с сетью мы попробовали, используя уже и мышь и клавиатуру, зайти в интернет, щелкнув на иконке браузера. Сайты открывались без проблем, с приемлемой скоростью.
3. Знакомство с GPIO, программированием на Python и запуск светофора
Контакты GPIO, безусловно, являются очень интересной частью Raspberry, значительно расширяющей возможности микрокомпьютера для применения в электронных автоматизированных системах. С помощью этих контактов можно как считывать данные с огромного множества предлагаемых сегодня датчиков: температуры, давления, движения, наклона, ориентации, открытия и т.п., так и посылать команды на исполнительные устройства: реле, двигатели, актуаторы, серво-машины и многие другие.
Вот схема 40-контактного разъема GPIO:
Как видно, кроме обычных цифровых пинов вход/выход, принимающих или выдающих значения логических 0 и 1, имеются контакты, работающие по распространенным интерфейсам I 2 C, SPI и UART. Также есть возможность генерации ШИМ и прерываний от изменения уровней на входах.
Используем GPIO для моделирования работы светофора по нажатию кнопки, как это делается на редко используемых пешеходных переходах, где обычно горит зеленый свет для транспорта, а пешеход может кнопкой запустить программу включения красного света для транспорта. Алгоритм этой программы такой: при нажатии кнопки начинает мигать зеленый свет, затем на короткое время зажигается желтый, затем красный; красный свет горит некоторое время, затем короткое время горят красный и желтый, и, наконец, снова зеленый; далее система ждет очередного нажатия кнопки.
Для программирования этого алгоритма воспользуемся встроенной в образ ОС Raspbian интегрированной среды разработки (IDE) на языке Python (Пайтон). Язык Python имеет большое число достоинств, о которых можно почитать в сети, что делает его весьма хорошим инструментом как для начинающих программистов, так и для профессионалов. Это интепретирущий язык, его команды выполняются последовательно, одна за другой. В IDE Python команды можно выполнять, просто вводя их с клавиатуры и нажимая клавишу Enter в конце строки.
Среда разработки программ на языке Python запускается с рабочего стола последовательным выбором Menu - Programming - Python 3 . Далее, в открывшемся окне Python Shell следует нажать File - New File . В открывшемся окне редактора нужно набрать или скопировать следущий текст программы, обращая особое внимания на отступы в тексте, так как для программ на Python они имеют принципиальное значение:
#!/usr/bin/python
import RPi.GPIO as GPIO
from time import sleep
RED_PIN = 36
YELLOW_PIN = 32
GREEN_PIN = 29
BUTTON_PIN = 40
print ("RPi.GPIO init start")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
print ("RPi.GPIO init end")
print ("GPIO setup")
GPIO.setup(RED_PIN, GPIO.OUT)
GPIO.setup(YELLOW_PIN, GPIO.OUT)
GPIO.setup(GREEN_PIN, GPIO.OUT)
GPIO.setup(BUTTON_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.output(RED_PIN, 0)
GPIO.output(YELLOW_PIN, 0)
GPIO.output(GREEN_PIN, 1)
while True:
if inp==0:
for x in range(0, 5):
GPIO.output(GREEN_PIN, 1)
sleep(0.5)
GPIO.output(GREEN_PIN, 0)
sleep(0.5)
GPIO.output(YELLOW_PIN, 1)
sleep(2)
GPIO.output(YELLOW_PIN, 0)
GPIO.output(RED_PIN, 1)
sleep(5)
GPIO.output(YELLOW_PIN, 1)
sleep(1)
GPIO.output(RED_PIN, 0)
GPIO.output(YELLOW_PIN, 0)
GPIO.output(GREEN_PIN, 1)
Первая строка указывает, где в ОС находится интерпретатор Python.
Функция, начинающаяся с print , просто выводит свой аргумент на экран.
Строки, начинающиеся с GPIO.setup , задают режим выхода (OUT ) или входа (IN ) соответствующих пинов, а аргумент pull_up_down=GPIO.PUD_UP включает подтягивающий резистор на входе 40, к которому подключена кнопка. Поскольку программа на Python не имеет стандартного «вечного цикла», как, например в Ардуино, где загруженная в микроконтроллер программа выполняется бесконечно, пока подано питание, оператор while True: осуществляет этот цикл. Нам ведь надо возвращать наш светофор в исходное состояние всякий раз по завершению цикла его работы.
Оператор присвоения inp = GPIO.input(BUTTON_PIN) записывает в переменную inp значение на входе 40. Если кнопка не нажата - это 0, если нажата - 1. Если inp равно 0, то начинается цикл работы светофора:
- с помощью цикла for 5 раз мигает зеленый светодиод;
- на 2 секунды зажигается желтый (пауза задается оператором sleep);
- желтый гаснет, зажигается красный на 5 секунд и т д.
После окончания цикла работы светофора все начинается снова.
Теперь необходимо собрать электрическую схему с помощью проводов с разъемами без пайки:
 |
 |
Короткие ножки светодиодов (это минус) подключаем к земле - контакты 6, 14, 20; длинные (плюс) через резисторы 240 Ом - к контактам 29 (зеленый), 32 (желтый), 36 (красный).
Кнопку подключаем к контактам 39 и 40.
Теперь в редакторе с нашей программой выбираем Run - Run Modul или нажимаем F5, и программа начинает выполняться, ожидая нажатия кнопки.
Но вовсе неудобно каждый раз запускать программу с помощью оболочки. Удобнее, чтобы наша программа запускалась при включении питания Raspberry, ведь тогда устройство можно использовать автономно, без монитора, клавиатуры и мыши.
Для этого необходимо включить нашу программу в автозагрузку операционной системы.
Тут нам понадобится терминал, без него обойтись.
Сначала сохраним нашу программу в виде файла svetofor-rpi.py3 в корневом каталоге пользователя /home/pi .
Теперь запустим терминал и после приглашения pi@raspberrypi:~ $ наберем следующую строку: gksudo leafpad /etc/xdg/autostart/Svetofor.desktop .
Тем самым мы вызовем текстовый редактор leafpad и создадим файл Svetofor.desktop в папке автозапуска.
В текстовом редакторе набираем следующее:
Version=1.0
Encoding=UTF-8
Name=Svetofor
Comment=
Exec=sudo python /home/pi/svetofor-rpi.py3
Terminal=false
Type=Application
и сохраняем файл.
Основное в этом файле - строка, начинающаяся с Exec , которая запускает интерпретатор Python на выполнение программы svetofor-rpi.py3 .
Можно проверить, зайдя в папку /etc/xdg/autostart с помощью файлового менеджера, чья иконка в виде двух ящичков расположена в левом углу экрана, появился ли в этой папке файл Svetofor.
Теперь, если выключить питание, отключить монитор, мышь и клавиатуру, и снова включить питание, наш светофор начнет работать в автономном режиме!
Видео работы светофора:
