Как программировать Raspberry Pi на языке C. Программы для 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 Ом.

Во всех следующих примерах будет использовано такое подключение. Различные библиотеки используют различные выводы, создавая путаницу, поэтому я постараюсь избавиться от неё. Также отметим, что всё это делается в режиме 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)

Bash

Я всегда любил 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. Базовый пример для 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, поэтому мы можем написать небольшую программу с использованием её.

cd ~
nano blink.c

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

/* * blink.c: * Simple test program to blink an LED on pin 7 */ #include #include int main (void) { int pin = 7; printf("Raspberry Pi wiringPi blink test\n"); if (wiringPiSetup() == -1) exit (1); pinMode(pin, OUTPUT); for (;;){ printf("LED On\n"); digitalWrite(pin, 1); delay(250); printf("LED Off\n"); digitalWrite(pin, 0); delay(250); } return 0; }

Компилируем код:

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

И запускаем:

sudo ./blink

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

/* * buttonLED.c: * Simple test program to change the blinking rate of an LED when a button is pressed */ #include #include int main (void) { int pin_LED = 7; // GPIO7 / header pin 7 int pin_switch = 8; // SDA0 / header pin 3 int del = 250; printf ("Raspberry Pi wiringPi button LED test\n") ; if (wiringPiSetup() == -1) exit (1); pinMode(pin_LED, OUTPUT); pinMode(pin_switch, INPUT); for (;;){ if (digitalRead (8) == 0){ // button pressed del = 100; } else { del = 250; } digitalWrite(pin_LED, 1); delay(del); digitalWrite(pin_LED, 0); delay(del); } return 0 ; }

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

Что делать, когда нечего делать?
Попробовать что-нибудь новое!

Если вы приобрели 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 -эта строка говорит компилятору, что в программе используется заголовочный файл bcm2835.h. В этом файле находятся все описания функций и идентификаторы портов GPIO.

>#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 не только отдавать команды другим устройством, но и слушать их.А пока можете начинать изучать язык Си. А так же попробуйте изменить эту программу так, чтобы светдиод управлялся бы другим портом и испытайте её.

Я не особо большой знаток Linux (почти новичок), поэтому буду очень рад конструктивной критике в комментариях.

Все, кто хотел, давно купили себе Raspberry Pi 3, а я ждал непонятно чего 🙂 Однако недавно этот компьютер попал ко мне в руки, поэтому хочу поделится впечатлениями и полезными (для кого-то) советами по его настройке.

Аппаратная часть

Компьютер заказывался на AliExpress сразу с корпусом и блоком питания (Model B, 1 ГБ ОЗУ). Карта памяти, microSD SanDisk 16 GB class 10, уже валялась дома. С учётом её цены весь «системный блок» стоил примерно 3000 р.

В качестве экрана был подключён обычный телевизор Full HD (кабель HDMI в кладовке случайно завалялся). Из периферии изначально подключил только клавиатуру и мышь, подсоединив их к USB-портам.

Raspberry в определённых случаях ощутимо греется (показывая при этом иконку-градусник в правом верхнем углу экрана), поэтому в корпусе почти сразу были просверлены дополнительные вентиляционные отверстия. Эффективность комплектных радиаторов так себе, нужно искать что-то посерьёзнее, если собираетесь нагружать компьютер на 100%.

Операционная система

Выбор ОС для Raspberry Pi 3 - вопрос деликатный. Если кто-то не в курсе, то здесь ARM-процессор. Т. е. обычный дистрибутив Linux на устройство не встанет, нужна специально подготовленная сборка.

Собственно, из-за относительно специфичного железа в дальнейшем будет много других сложностей с программами и т. п.

Существует несколько официальных и неофициальных сборок Linux для этого мини-компьютера. Какую из них использовать - зависит от поставленной задачи. В моём случае Raspberry Pi 3 будет использоваться, как обычный домашний компьютер для работы и развлечений (звучит несколько амбициозно). Попробовав несколько ОС, я остановился на основном официальном дистрибутиве, Raspbian Stretch 9.1 (новейшем на тот момент). На мой взгляд, он быстрее, стабильнее и универсальнее остальных.

Установка ОС на «Малину» очень проста. Скачиваем образ, распаковываем файл.img и записываем его на карту памяти с помощью специальной программы (для Windows это, например, Win32 Disk Imager).

Более подробное описание процесса записи ОС легко найти в Интернете.

После окончания записи карту памяти нужно вставить в соответствующий слот Raspberry Pi. Затем включаем устройство в электрическую сеть и начинаем первоначальную настройку (вставка блока питания в розетку - штатный способ включения этого компьютера).

Если вы подумали, что Raspberry Pi 3 сможет на равных конкурировать с обычным домашним компьютером за 20 000 р., то это совсем не так. Работать Raspberry будет гораздо медленнее, а ряд задач для него вообще недоступен. Однако с определёнными функциями мини-компьютер справляется неплохо. Например, с ролью терминала для не слишком «тяжёлых» веб-приложений он справится отлично.

Настройка Raspberry Pi 3 (ОС Raspbian)

При первом запуске даже ничего не нужно выбирать и нажимать. Система уже практически готова к работе. После перезагрузки появляется рабочий стол.

Хотя радоваться здесь особо нечему - просто придётся больше вещей настраивать уже в установленной системе 😉

Сначала подключаемся к Интернету. При проводном соединении Интернет уже должен работать сам. В моём случае используется Wi-Fi, поэтому нужно нажать на красные кресты на панели задач (иконка сетевых подключений), выбрать беспроводную сеть и ввести пароль. Всё почти так же, как в других операционных системах.

Она позволит выполнять все дальнейшие действия в терминале с правами суперпользователя. В противном случае придётся добавлять sudo в начале каждой второй строки (а то и чаще).

Все остальные команды приведены в статье без sudo. Т. е. предполагается, что вышеописанная рекомендация была выполнена.

Сразу обновляем пакетную базу и прошивку устройства:

Apt update apt upgrade rpi-update

Затем заходим в настройки Raspberry Pi: «Пуск» (значок малины) > Preferences > Raspberry Pi Configuration. Нажимаем «Change Password…» и задаём новый пароль (одновременно для пользователя и суперпользователя). Это позволит избежать некоторых проблем в будущем.

По умолчанию в Raspbian создан пользователь pi с паролем raspberry.

Настраиваем дальше. Hostname (имя компьютера в сети) можно не менять. У меня изображение выводится не на весь экран (толстая чёрная рамка по периметру), поэтому параметр Underscan переключаю в положение «Disabled». На вкладке «Performance» изменяем значение GPU Memory на 128 (можно и 64 оставить, но некоторым приложениям может не хватить).

Переходим во вкладку «Localization». Нажимаем «Set Locale…». Выбираем Language: ru (это даст хоть какой-то перевод ОС на русский). Настраиваем время через «Set Timezone…». В моём случае Europe/Moscow. Выбираем основную раскладку клавиатуры через «Set Keyboard…». Советую United States/English (US), т. к. к ней все уже привыкли. На всяких случай заходим в «Set Wi-Fi Country…» и тоже выбираем RU.

После всего этого нажимаем «OK» внизу окна и соглашаемся на перезагрузку.

Для интереса посмотрим сколько ОЗУ занимает операционная система в новом состоянии (диспетчер задач вызывается через Ctrl + Alt + Del или из меню приложений). 92 МБ! Вот бы Windows столько занимала 🙂

Настройка внешнего вида

Для удобства приводим рабочий стол к более привычному виду (в данном случае к виду подобному Windows). Правый клик по панели, «Panel Settings». Edge переключаем в положение «Botton» - панель перемещается вниз. Переходим во вкладку «Panel Applets», удаляем лишнее, добавляем нужное. Удалил Ejecter и CPU Usage Monitor. Добавил Minimize All Windows и Keyboard Layout Handler (переключатель раскладки клавиатуры).

Через последний добавляем русскую раскладку. Правый клик по флагу, «Keyboard Layout Handler Setting». Снимаем флажок «Keep system layouts», нажимаем «Добавить», выбираем ru. Меняем сочетание клавиш для переключения раскладок кнопкой под надписью Change Layout Options.

Кнопка «Закрыть» в этом окне не работает, но работает крестик в углу. Это старый баг многих сборок Linux (странно, что его не убрали до сих пор).

На панели есть значок Bluetooth. Отключаем через него модуль Bluetooth, если не собираемся подключать какие-либо беспроводные устройства.

Меняем набор значков слева. Правый клик на одном из значков, «Application Launch Bar Settings». Вытаскиваем пару ярлыков из меню на рабочий стол. Меняем обои (предпочитаю что-то более однотонное):

Numlock

К этому времени не работающая цифровая клавиатура уже начала раздражать. При загрузке системы Numlock выключен (в других версиях Linux такое тоже бывает). Каждый раз включать его не хочется. Пора исправить ситуацию. Устанавливаем программу numlockx:

Apt install numlockx

Добавляем её в автозагрузку. Например, открываем файловый менеджер, переходим в папку /home/pi/.config , создаём там файл autostart (без расширения) с единственной строкой: @numlockx -on .

Можете использовать любой другой способ добавления в автозагрузку.

Проблема с USB-флешками и жёсткими дисками

На первый взгляд, со съёмными носителями всё в порядке. Они корректно определяются при подключении, все файлы отображаются и нормально открываются. Только вот записывать на флешки ничего нельзя, т. к. подключаются они в режиме «readonly» (за редким исключением).

Решается проблема просто, установкой дополнительного драйвера:

Apt install ntfs-3g

После установки требуется перезагрузить систему.

Проверялись все накопители, имеющиеся в распоряжении - запись, изменение и удаление стали работать (не только в NTFS, но и в FAT32).

На одном USB-накопителе небольшого объёма только что отформатированном в Windows проблемы почему-то не было изначально.

Программы в комплекте

Настало время посмотреть, что уже установлено в системе. Просто пробежимся по меню приложений (консольные утилиты в расчёт не берём).

В разделе «Программирование» находится больше десятка приложений собственно для программирования (оставим их без внимания).

Категория «Офис» содержит исключительно программы из пакета LibreOffice (знаменитого бесплатного аналога Microsoft Office). Полезные приложения для работы с документами. Создание и правка не очень сложных файлов в них на Raspberry Pi 3 происходит с минимальными притормаживаниями.

Раздел «Интернет» содержит, на мой взгляд, два полезных приложения. Первое - VNC Viewer. Неплохой вариант управления удалёнными устройствами. Скорость работы приемлемая. Второе - браузер Chromium. Практически тот же Chrome, только без излишеств. Сайты работают с разной скоростью. Некоторые прямо быстро, некоторые очень туго (зависит от типа сайта и его оптимизации). Например, ВКонтакте листается с небольшими рывками, а Одноклассники уже идут со скрипом (хотя в целом пользоваться можно и тем и другим). Даже YouTube в нём сносно работает (установлено специальное расширение). В полноэкранном режиме видео, конечно, дёргается, а вот в широкоэкранном смотрится нормально. Т. е. на этом компьютере более или менее доступна работа в Интернете (по крайней мере, она комфортнее, чем на среднем смартфоне).

При работе на Raspberry Pi 3 в большинстве приложений заметен небольшой разрыв кадра (нижняя часть изображения обновляется чуть позже верхней). Эта неприятность связана с отсутствием вертикальной синхронизации (tearing). На обычных компьютерах проблема легко решается, но для Raspbian решения я не нашёл. Опять же многое упирается в специфическое железо.

В «Стандартных» минимальный набор полезных приложений: калькулятор, терминал, просмотрщик файлов PDF, блокнот, архиватор (который почти ничего не умеет), диспетчер задач, программа для просмотра изображений, файловый менеджер и утилита для создания копии системы - SD Card Copier.

Всё необходимое есть, лишнего немного, остальное ставим по потребностям.

Skype

Со Skype в Linux почти всегда были какие-то заморочки. Нынешняя версия является просто оболочкой для веб-интерфейса. Вместо того, чтобы пытаться запустить её под Raspbian, просто воспользуемся веб-версией напрямую.

В Raspberry Pi 3 отсутствует разъём mini-jack для микрофона. Вариант 1 - найти микрофон с разъёмом USB. Вариант 2 - подключить дешёвую внешнюю USB-звуковую карту с привычными разъёмами. В моём случае всё было ещё проще (хотя не совсем) - веб-камера оказалась со встроенным микрофоном, т. е. два устройства заняли только одно гнездо.

Откроем Skype. Через Chromium заходим по адресу web.skype.com/ru и выполняем вход в свой аккаунт. Затем нажимаем на зелёный замок в адресной строке: разрешаем камеру, микрофон и Flash. Микрофон работать всё равно не хотел. Оказалось, что нужно было кликнуть по значку видеокамеры (в адресной строке справа), затем вместо по «По умолчанию» выбрать правильное аудиоустройство.

Сделал тестовый видеозвонок знакомым. Звук в обе стороны проходит нормально, видео тоже передаётся (немного притормаживает).

Расширение офисных приложений

Пакет LibreOffice, конечно, неплох, но сейчас он на английском, не проверяет правописание и не очень правильно отображает документы MS Office, т. к. в системе нет ни одного шрифта из Windows. Открываем терминал, устанавливаем русскую локализацию, орфографический словарь и шрифты:

Apt install libreoffice-l10n-ru hunspell hunspell-ru ttf-mscorefonts-installer

Вот так гораздо привычнее:

Наш штатный архиватор умеет работать только с типичными для Linux форматами, поэтому нужно помочь ему, добавив поддержку более ходовых типов архивов (7z, RAR и ещё парочки):

Apt install p7zip-full unrar-free

Установим более продвинутые программы для чтения электронных книг Evince и FBReader, чтобы открывать разные типы электронных книг:

Apt install evince fbreader

Evince у меня не появился в меню самостоятельно, поэтому пришлось зайти в «Параметры» > «Main Menu Editor» и отметить его флажком.

Настройка локальной сети

Если у вас есть локальная сеть, то Raspberry Pi 3 уже подключен к ней (в случае открытой и корректно настроенной сети). Чтобы иметь к ней удобный доступ, в стандартном файловом менеджере нужно открыть меню «Перейти», выбрать «Сеть», открыть меню «Закладки», нажать «Добавить в закладки», переключить вид «Дерево директорий» на «Точки входа». Теперь ссылка на сеть будет под рукой при каждом открытии файлового менеджера.

Также можно установить другой файловый менеджер, например, Thunar.

Вроде, всё неплохо: сетевые ресурсы доступны, файлы открываются, копируются и даже удаляются. Только при входе чуть ли не в каждую сетевую папку система запрашивает пароль (который мы меняли в самом начале работы с ОС). Другие компьютеры в моей сети (и на Windows, и на Linux) заходят на те же ресурсы без паролей. Убрать ввод этого пароля пока не удалось (ввожу каждый раз).

Для того, чтобы компьютеры, входящие в ЛВС, отображались на верхнем уровне, правим настройки Samba /etc/samba/smb.conf . Только файл нужно открыть с правами суперпользователя. Например, вводим в терминале следующую команду (предварительно выполнив sudo -i ):

Leafpad /etc/samba/smb.conf

Меняем значение параметра workgroup на название нашей рабочей группы, сохраняем изменения, делаем перезагрузку. Теперь при заходе в «Сеть» можно сразу переходить к нужному компьютеру (не открывая ещё две папки).

Настройки сети приведены для примера. В других случаях данный подход к работе с ЛВС может просто не сработать.

Подключение к сетевому принтеру

Раз уж у нас есть офисные программы, то и печать документов, скорее всего, потребуется. В рассмотренной выше сети установлен единственный принтер, подключённый к ПК на Windows 10. Принтер уже сетевой, но нужно как-то добавить его в Raspbian. Для этого установим программы CUPS и samba-client:

Apt install samba-client cups

CUPS не пустит нас в настройки просто так. Поэтому нужно добавить нашего текущего пользователя в группу lpadmin:

Usermod -aG lpadmin pi

Управление в CUPS происходит через веб-интерфейс. Вводим в браузер адрес 127.0.0.1:631 , затем переходим в раздел «Администрирование», нажимаем «Добавить принтер». Вводим имя пользователя pi и пароль, который задали при настройке системы (в начале статьи). Отмечаем «Windows Printer via SAMBA» и нажимаем «Продолжить».

Дальше важный момент. В поле «Подключение» нужно ввести адрес принтера в сети. В данном случае smb://192.168.1.6/hp1010 . Из чего он состоит: smb:// - протокол SAMBA, 192.168.1.6 - локальный адрес компьютера, к которому подключён принтер, hp1010 - сетевое имя принтера.

Адрес компьютера в ЛВС должен быть статическим, а имя принтера желательно задавать только латиницей (без пробелов).

Нажимаем «Продолжить». Вводим название принтера для нашей системы и на всякий случай ставим флажок «Разрешить совместный доступ к этому принтеру», нажимаем «Продолжить». Выбираем драйвер для принтера (список впечатляет), нажимаем «Добавить принтер». Сохраняем параметры. Печатаем для теста какой-нибудь документ и радуемся жизни.

Работа с графикой

На Raspberry Pi 3 можно установить классические графические редакторы GIMP и Inkscape:

Apt install gimp inkscape

Работают они в целом корректно, но медленно. Несложные манипуляции с не очень большими картинками мини-компьютер потянет (обрезать фотографию, цвета поправить, надпись добавить, логотип нарисовать). Серьёзные графические задачи, естественно, требуют серьёзной мощности.

Просмотр видео

Вот здесь всё опять упирается в нестандартное железо. Привычные плееры просто на нём не работают (либо работают с большими проблемами). Получилось найти только две программы, которые справляются с проигрыванием видео: OMXPlayer и Kodi. Использовать будем обе.

OMXPlayer уже установлен в системе, но он консольный, поэтому пользоваться им не слишком удобно. Чтобы видеофайлы открывались двойным кликом делаем следующее. Кликаем по файлу правой кнопкой, выбираем «Открыть с помощью…». Переходим на вкладку «Пользовательская команда». В верхней строке вводим omxplayer -b . Отмечаем флажками «Выполнить в эмуляторе терминала» и «Установить выбранное приложение по умолчанию для данного типа файла». В имени приложения пишем, например, omxplayer . Нажимаем «OK».

Эти действия нужно проделать для каждого расширения видеофайлов.

Переключатся между окнами OMXPlayer не даёт. Клавиши управления: «q» - выход, «-» и «+» - регулировка громкости, «←» и «→» - перемотка.

Kodi - это довольно серьёзный медиацентр. Понимает значительно больше кодеков, чем OMXPlayer, имеет встроенный DLNA-клиент и другие плюшки. Для начала его нужно установить:

Wi-Fi у Raspberry слабоват, поэтому видео приличного размера по сети смотреть через него не получится. Позаботьтесь о проводном подключении.

С Kodi на Raspberry Pi 3 можно смотреть весьма увесистые фильмы. Проверял на файле Full HD размером 40 ГБ с битрейтом 40 Мб/с (по DLNA). За 2 с лишним часа ни одного подтормаживания или других проблем. Некоторые Smart-телевизоры при проигрывании этого же файла с того же DLNA-сервера зависали на середине видео (приходилось выключать/включать).

Прослушивание музыки

С воспроизведением звука всё гораздо проще. Поддерживаются многие проигрыватели. Штатный OMXPlayer тоже умеет играть музыку, но в этом нет необходимости. Был установлен Audacious, который ничем особо не перегружен, но имеет привычный вид и нормальный функционал:

Apt install audacious

Торрент-клиент

Здесь тоже всё нормально. Установил Deluge:

Apt install deluge

Почему именно его? Потому что привык к нему. Deluge не лучше и не хуже других. Просто выполняет свою работу как полагается. Для теста скачал через него Raspbian Stretch Lite. Никаких проблем не заметил.

Игры

Конечно, сложно назвать Raspberry Pi игровой платформой, однако поиграть на нём вполне возможно. Речь по большей части идёт о запуске игр, выходивших на старых приставках. Долгие попытки собрать что-то вроде RetroPie в виде отдельного приложения (а не целой ОС) не увенчались успехом. Поиск отдельных приложений для каждой приставки тоже довольно нудное дело, поэтом остановился на Mednafen:

Apt install mednafen

Первым делом переходим в «Global Settings» и выбираем Video Driver sdl вместо opengl (ну нет у «Малины» нормальной поддержки OpenGL). После этого образы игр (ROMs) начнут нормально работать (не все, конечно).

С нормальной скоростью заработали только NES и Sega Mega Drive (хотя большинство платформ не проверялось, т. к. нет к ним интереса).

Можно добавлять игры в интерфейс Mednaffe и запускать их оттуда, а можно даже не запускать Mednaffe - просто открывать файл с образом игры, как любой другой, двойным кликом (не для всех платформ сработает).

Играть в приставочные игры на клавиатуре неудобно, а под рукой как раз есть геймпад от Xbox 360. Контроллер работает без дополнительных драйверов, остаётся только настроить кнопки. Для этого в Mednaffe открываем раздел «Systems», переходим к нужной приставке, открываем подраздел «Input», нажимаем «Controller Setup». Выбираем «Port 1» (первый контроллер), делаем двойной клик в столбце Key и нажимаем на геймпаде кнопку, соответствующую надписи в столбце Action/Button (для каждой строки).

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

Несколько «родных» игр, заслуживающих внимания, тоже можно установить. Например, Битва за Веснот (напоминает HOMM III) и OpenTTD (напоминает SimCity 2000). Обе игры переведены на русский язык.

Apt install wesnoth openttd

Последний штрих

После установки многих программ остаётся всякий «мусор». Хорошо бы его удалить следующей командой (ещё и немного места освободится):

Apt autoremove

Дополнительные сведения

• Снимок экрана делается клавишей Print Screen и автоматически сохраняется в домашнюю папку (/home/pi).
• Если хотите немного повысить скорость работы Raspberry Pi 3, подключите его к экрану с низким разрешением (например, 1366×768).
• Приложения можно поискать в штатной утилите «Add / Remove Software», которая чем-то похожа на Synaptic.
• Для подключения к монитору без разъёма HDMI может использоваться дешёвый переходник с HDMI на DVI-D или такой же кабель.
• Raspberry может показывать на экране три специальных значка-индикатора (независимо от установленной ОС и среды рабочего стола): молния - низкое напряжение, наполовину красный термометр - высокая температура чипа (80–85 градусов), полностью красный термометр - критическая температура (выше 85 градусов).

Заключение

В целом мини-компьютером я остался доволен. За свою стоимость он предоставляет очень даже широкий функционал (в статье рассмотрены только некоторые варианты его использования). Для опытных пользователей Linux настройка Raspberry Pi 3 покажется несложной. Остальные без проблем смогут использовать уже настроенную систему.

Кликать мышью по окнам можно хоть кота научить.

Помимо энтузиастов Raspberry может быть интересен и компаниям с большим парком машин. Например, покупка 20 классических системных блоков для колл-центра по 12 000 р. и покупка 20 «малиновых» компьютеров по 3000 р. - это совсем разные вещи (180 000 р. экономии).

Только мониторы нужно брать хотя бы с DVI-D - ещё 15 000 вычитаем.

При домашнем использовании Raspberry Pi 3 хорошо справится с ролью бесшумного медиасервера, ретро-приставки, вспомогательного компьютера для другой комнаты и т. д и т. п…

Как-то я писал о том, что планирую использовать Raspberry Pi в качестве веб-сервера, управляющего моим устройством. Пришло время задуматься над интерфейсом подключения. У разработчика, желающего подключить свое железо к Raspberry есть два пути: использовать для этого USB или выводы общего назначения (GPIO ). С возможностями USB все приблизительно понятно (в будущем постараюсь написать пост о работе с внешним железом через USB ). О GPIO же информации не так много, да и опыта его использования нет. В общем я заинтересовался GPIO и его возможностями. В статье речь пойдет о выводах общего назначения Raspberry Pi - GPIO :

• возможности GPIO
• распиновка GPIO
• как работать с GPIO на Python
• характеристики GPIO (прежде всего показатели скорости)
• пример использования GPIO Raspberry

Порт GPIO - выводы общего назначения Raspberry Pi

Предварительно я , чтобы каждый раз не подключать монитор и клавиатуру. Поэтому в исходном состоянии у меня к Raspberry подключено всего два "провода": питание и сетевой кабель для соединения с роутером. Хотя принципиального значения это не имеет: все нижеописанное будет справедливо, как в случае работы с консолью Raspberry через SSH , так и при использовании подключенной клавиатуры.

Порт GPIO (сокращение от General Purpose Input Output ) - это программно управляемые выводы общего назначения, которые могут работать как входы (для считывания сигнала) или как выходы (для передачи сигнала). На Raspberry Pi они выполнены в виде двух рядов штырьков с шагом в 2,54 мм (разъем PLD ). Выражение "общего назначения" означает, что эти выводы пользователь может использовать в своих целях так, как ему захочется, поскольку они не выполняют каких-то определенных жестко заданных функций. При работе с GPIO следует только иметь ввиду, что это цифровые выводы с максимальным уровнем напряжения 3,3 В, соответствующим логической единице. Поэтому программно выводить на GPIO аналоговый сигнал или подавать на него аналоговый сигнал извне для последующий оцифровки нельзя.

Итак, что представляет собой порт GPIO и каковы его возможности? GPIO объединяет в себе 26 выводов, среди которых присутствуют следующие:

• 2 вывода с постоянным уровнем напряжения 5 В
• 2 вывода с постоянным уровнем напряжения 3,3 В
• 5 общих выводов (земля)
• 17 цифровых программно управляемых выводов

Каждый из этих 17 выводов может работать как вход, либо как выход. Однако помимо этого, некоторые из этих выводов могут выполнять альтернативные необязательные функции. Что это значит? Каждый из таких выводов в зависимости от программной настройки могут работать либо как обычный вывод, либо как вывод одного из последовательных интерфейсов. С помощью таких выводов GPIO альтернативно могут реализовываться последовательные интерфейсы I2C , SPI и другие последовательные интерфейсы посредством UART .

Примечание: Это знакомые понятия для тех, кто сталкивался с программированием микроконтроллеров. Для тех, кто не сталкивался и на данном этапе пока желает просто программно выводить "1" и "0" на нужном выводе - знания этих интерфейсов не понадобится. Поэтому не буду здесь уделять этому внимание. Скажу только, что среди микроконтроллеров и других устройств (различные датчики, АЦП, ЦАП, микросхемы памяти) это очень распространенные интерфейсы, поэтому наличие выводов этих интерфейсов в GPIO Raspberry при необходимости позволяет очень легко и с минимумом программного кода "научить" Raspberry "общаться" с вашим устройством.

Как понять где какой вывод находится? Для этого необходима распиновка (цоколевка) GPIO . В официальной документации приведена распиновка разных версий GPIO Raspberry Pi . Здесь я приведу самую последнюю на данный момент распиновку GPIO - для Raspberry Pi Model B Rev.2 :

На схеме в скобках указана альтернативная функция каждого вывода:

• SDA , SCL - выводы интерфейса I2C
• TXD , RXD - выводы UART
• MOSI , MISO , SCLK , CE0 , CE1 - выводы интерфейса SPI
• GPCLK0 - (General Purpose Clock ) вывод для формирования варьируемой тактовой частоты для внешних устройств
• PCM_CLK , PCM_DOUT - выводы аудио-интерфейса I2S

Что ВАЖНО знать перед работой с GPIO Raspberry Pi

Пожалуй, это самый важный раздел. Нужно помнить о некоторых особенностях GPIO и соблюдать определенные меры предосторожности, чтобы не залететь еще на 35-50$ не повредить Raspberry . Ниже приведены такие "критические особенности", а также несколько нюансов, которые просто могут быть полезны, и которые желательно помнить при разработке.

• Максимальный суммарный ток обоих выводов 3.3 В равен 50 мА! Поэтому эти выводы могут использоваться для питания внешних устройств, только если их потребляемый ток меньше 50 мА.
• Максимальный суммарный ток обоих выводов 5 В равен 300 мА! Эти выводы также могут использоваться для питания внешних устройств только в том случае, если их потребляемый ток меньше 300 мА.
• Нельзя на GPIO подавать напряжение больше 3,3 В! Цифровые выводы GPIO имеют уровни напряжения 0 - 3,3 В и не совместимы с традиционными уровнями напряжения 0 - 5В ! Поэтому нельзя напрямую соединять Raspberry Pi и цифровые устройства, работающие с TTL -уровнями 5 В. Если подать на GPIO вывод Raspberry логическую единицу, представляющую собой 5 В, а не 3,3 В - вывод может выйти из строя.
• Выводы GPIO 14 и GPIO 15 по-умолчанию выполняют альтернативную функцию и являются выводами UART - RXD и TXD . Поэтому после включения на них присутствует высокий уровень 3,3 В. Программно их можно переконфигурировать в обычные выводы. Все остальные GPIO после включения Raspberry выполняют основную функцию и работают как обычные цифровые выводы.
• Все настраиваемые пины GPIO по-умолчанию являются входами. И поэтому имеют высокое входное сопротивление. При этом подтяжка логического уровня у них не включена, выводы "висят в воздухе", поэтому после включения Raspberry напряжение на них может "плавать". Это нормально. Исключением является только 2 следующих вывода:
• Выводы GPIO 0 (SDA) и GPIO 1 (SCL) по-умолчанию "подтянуты" к питанию. Поэтому после включения Raspberry на них присутствует напряжение логической единицы (3,3 В).
• Сигнал на любом из цифровых выводов может служить источником внешнего прерывания. Кто раньше сталкивался с микроконтроллерами поймет, насколько это может быть полезно. Как использовать прерывания в Raspberry Pi - пока это идея для следующего поста.

Пожалуй, все.. Ну и в целом нужно помнить, что GPIO - это выводы, непосредственно подключенные к процессору Raspberry Pi, они являются инструментом для взаимодействия с ним. Поэтому неосторожное обращение с GPIO может привести к необратимым последствиям для процессора. На этом с "пугалками" заканчиваю. Главное и простое правило - не подавать больших напряжений и не потреблять большой ток. Переходим к делу.

Как работать с GPIO на Python

Примечание: Работать с GPIO , по сути, можно двумя способами:

1) Используя bash и файловую систему Rasbian
Raspbian является одним из дистрибутивов Linux , а концепция Linux предполагает, что любой объект является файлом. Именно это позволяет выводить и считывать сигналы с GPIO обычными командами оболочки bash прямо в терминале! Вывод логической единицы при этом выглядит как команда записи "1" в файл, соответствующий нужному выводу. Подробные примеры даны .

2) Используя языки программирования (самые разные от C до Бэйсика)

Это более гибкий и более производительный вариант, поскольку он не требует обращения к файловой системе. При этом взаимодействовать с GPIO Raspberry можно на самых разных языках, внушительный список которых приведен вместе с примерами. Ниже разберем пример работы с GPIO на Python .

Предположим нам нужно вывести логическую "1" или "0" на GPIO 7 и считать сигнал с GPIO 8 .

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

3) Конфигурируем выводы
Поскольку мы будем выводить сигналы на GPIO 7 , конфигурируем его как выход, а GPIO 8 - как вход:
GPIO.setup(7, GPIO.OUT)
GPIO.setup(8, GPIO.IN)

Примечание: именно после выполнения этой команды на 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.output(7, False)
signal = GPIO.input(8)

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

На мой взгляд, из всех характеристик наиболее интересны временные параметры GPIO , а именно - насколько быстро может меняться состояние цифрового вывода из "1" в "0" и обратно, если управлять портом программно. Для проверки этого использовался следующий код:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(7, GPIO.OUT)
while (1):
GPIO.output(7, True)
GPIO.output(7, False)

Примечание: частота импульсов, изображенных на верхних картинках, может незначительно колебаться. Это связано с тем, что Linux на Raspberry многозадачна и не всегда уделяет нашей программе все процессорное время. Также следует иметь ввиду, что добавление дополнительных команд внутрь цикла while может существенно увеличить время каждого импульса.

По нижним картинкам можно оценить время переключения пина GPIO из одного состояния в другое (другими словами длительность переходного процесса) - оно составляет приблизительно 50 нс. Надо сказать, довольно неплохие результаты, однако и конкурировать по скорости с ПЛИС GPIO Raspberry Pi не может.

Примечание: о том, каких длительностей можно добиться с использованием C описано в .

Следует иметь ввиду, что те пины GPIO , которые работают в режиме последовательных интерфейсов, позволяют добиться больших скоростей , поскольку при работе последовательных интерфейсов на высоких скоростях процессор аппаратно формирует тактовые частоты и сигналы согласно правилам того или иного последовательного интерфейса. Так, например, с помощью вывода GPCLK0 можно получать импульсы частотой порядка 100 МГц и выше.

Пример использования GPIO Raspberry

Как можно применить все это на практике? Зачем выводить "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 .

Программирование 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 использовать именно "Пайтон".