«Как правильно выбрать ноутбук?» – вопрос, закономерный при появлении желания...
Raspberry Pi – мощная платформа для обработки информации, полученных от разнообразных устройств. Этот микрокомпьютер может стать основой для создания систем умного дома и устройств распознавания образов. Наиболее удобной и популярной средой программирования для Raspbian является Питон. В это статье мы узнаем, как настроить Python на Raspberry Pi и как установить библиотеку RPI.GPIO для работы с GPIO портами.
Установка и настройка Python на Raspbian
Python – один из самых известных и используемых языков программирования. Изначально язык Python должен был выступать в роли основного языка программирования для Raspberry Pi. В микрокомпьютере Raspberry Pi он используется для работы с датчиками через GPIO при помощи специальной библиотеки. Пакет Python уже установлен в операционной системе Raspbian в двух версиях – 2 и 3. Каждый элемент в системе Raspbian перед именем имеют приставку «python-».
Установка и инсталляция пакетов выполняются с помощью утилиты apt либо pip.
Установить пакет утилитой apt можно при помощи команд:
sudo apt-get update
sudo apt-get install python3-picamera
Это один из лучших методов установки программного обеспечения. Благодаря такой установке программы можно легко обновить до последней версии – для этого используются команды sudo apt-get update и sudo apt-get upgrade.
Удалить ненужные элементы можно, запустив команду sudo apt-get remove python3-rpi.gpio.
Полное удаление можно произвести, добавив к команде окончание –purge:
sudo apt-get remove python3-rpi.gpio –purge.
Установка пакетов через PIP. Этот инструмент нужно тогда, когда невозможно найти нужный пакет или его последнюю версию. В это случае установка проводится через PyPI – каталог пакетов Python. Установка так же не вызывает трудностей, как и в предыдущем случае. Сначала нужно установить пакет через apt:
sudo apt-get install python3-pip (на примере третьей версии)
Команда pip-3.2 устанавливает нужные документы и файлы для python. Например, установить любую библиотеку можно следующим образом:
pip-3.2 install library
Удалить – с помощью команды
pip-3.2 uninstall.
Сам язык программирования Python характеризуется простым синтексом и высокой функциональностью, поддерживает автоматическое управление памятью, многопоточность вычислений, обработку исключений. Для этого языка существует большое количество библиотек для самых разнообразных сфер применения. Существуют расширения для создания игр – Pygame, для работы с мультимедиа, обработки графики, различных вычислений.
Установка библиотеки RPi.GPIO
Библиотека RPi.GPIO написана специально для управления портами GPIO на языке python. Эти порты позволяют собирать данных с датчиков, управлять двигателями, ключами, реле и прочими устройствами с помощью программы.
В первую очередь нужно скачать архив с официального сайта . На странице можно увидеть большое количество версий библиотеки. Нужно выбрать самую свежую версию.
Архив будет загружен в папку загрузки по адресу /home/pi/Downloads. Нужно зайти в нее, найти скачанный архив, нажать правую кнопку мыши и выбрать во всплывающем меню Extract Here.
Эта команда разархивирует библиотеку в папку, в которую помещен архив. Рядом с ним будет добавлена новая папка с названием RPi.GPIO-0.6.3.
Следующим шагом нужно установить python-dev. Запускается терминал и в него вводится команда
sudo apt-get install python-dev
Будет задан вопрос «Do you want to continue? », нужно нажать «Yes» и Enter.
В окне высветится отчет, который сообщает об успешно проведенной установке.
Чтобы установить библиотеку RPi.GPIO, нужно не закрывая перейти в папку, которая была распакована до этого.
cd /home/pi/Downloads/RPi.GPIO-0.6.3
Затем нужно запустить команду:
python setup.py build
На экране появится отчет о выполнении.
После этого нужно запустить установку библиотеки с помощью команды
sudo python setup.py install
После успешной установки на экране появится новый отчет.
Библиотека установлена, можно начинать работать.
Помимо вышеописанной библиотеки RPi.GPIO существуют и другие. Для доступа к GPIO контактам используется также библиотека WiringPi. Эта библиотека написана на языке C, используется в средах C, C++ и RTB (BASIC) и других. Она создавалась схожей с библиотекой Wiring на Ардуино.
Для программирования и настройки контактов вместе с библиотекой используется утилита gpio для командной строки. Она позволяет записывать и считывать данных с портов и управлять ими.
Raspberry PI - это устройство имеющее достаточную производительность для того чтобы на его основе могли быть построены роботы способные распознавать образы, выполнять работу людей и прочие подобные устройства для автоматизации и выполнения сложных вычислительных действий. Т.к. тактовая частота процессора Raspberry PI 3 м.б. 1.2 ГГц а его разрядность 32 бита то Raspberry PI 3 значительно превосходит обычное Arduino у которого тактовая частота как правило 16 МГц а разрядность микроконтроллера 8 бит, Arduino безусловно занимает своё место в выполнении операций не требующих большой производительности но когда её уже не хватает Raspberry PI "приходит на помощь" и перекрывает такой большой диапазон возможных применений что можно быть абсолютно уверенным в целесообразности приобретения данного одноплатного компьютера Raspberry PI 3 (можно заказать по ссылке) . Т.к. Raspberry PI - это компьютер то для того чтобы его использовать нужно на него установить операционную систему (хотя существуют обходные пути но всё же лучше и проще установить операционную систему (ос далее)). Существует много ос которые можно установить на Raspberry Pi но одной из самых популярных (для использования с Raspberry Pi), наиболее подходящих для начинающих является ос Raspbian. Для того чтобы установить ос на Raspberry Pi понадобиться micro sd карта с расширителем для того чтобы её можно было вставить в обычный компьютер и записать на неё ос. Sd карта должна иметь не менее 4Гб памяти при установке полной версии Raspbian и не менее 8Гб для установки минимальных версий Raspbian. Минимальные версии могут не иметь (и скорее всего не имеют) графического интерфейса и много всего остального что может считаться лишним и занимает место. Для избежания проблем с отсутствием необходимых файлов, можно поставить полную версию. Можно использовать SD карту 10го класса и с 32Гб памяти (проверено работает (как см. видео ниже)). После приобретения карты памяти её надо вставить в компьютер в соответствующий разъём, после этого посмотреть с какой буквой появился диск в разделе "мой компьютер" и запомнить, потом надо скачать ос с официального сайта https://www.raspberrypi.org/downloads/raspbian/ нажав кнопку "Download ZIP" под "RASPBIAN JESSIE" для скачивания полной версии или под "RASPBIAN JESSIE LITE" для скачивания облегчённой но, для начинающих, лучше выбрать "RASPBIAN JESSIE" т.е. полную версию. После скачивания архива "RASPBIAN JESSIE" его нужно разархивировать, потом скачать программу (или от сюда https://yadi.sk/d/SGGe1lMNs69YQ), установить её, открыть, далее нужно в правом верхнем углу указать букву диска (запомненную ранее), найти разархивированный образ ос
И нажать кнопку "write".
После чего выведется окно с предупреждением и в этом окне надо нажать кнопку "Yes",
После того как запись закончиться и появится окно сообщающее об успешной записи (Write Successful) нужно нажать кнопку "Ok" в этом окне.
Потом закрыть программу, вытащить SD карту безопасным способом и вставить в Raspberry Pi.
Далее можно подключить к Raspberry Pi usb клавиатуру (или ps2 через переходник), usb мышь и монитор или телевизор через hdmi кабель или можно подключить ethernet кабель (но это для опытных пользователей поэтому далее рассмотрим первый вариант). После этого надо подключить питание через micro usb например от зарядного устройства от смартфона. После подключения питания начнётся установка операционной системы. Как правило в новых (на момент написания данной статьи) версиях ос уже настроена возможность связи с Raspberry Pi по SSH и поэтому для того чтобы настроить связь с Raspberry Pi 3 по wifi достаточно настроить только wifi, Для этого в правом верхнем углу экрана есть значёк на который нужно нажать и выбрать wifi,
После чего вписать пароль от данного wifi в появившееся текстовое поле,
После этих действий wifi на Raspberry Pi 3 будет настроен и дальше можно будет не используя провода программировать Raspberry Pi 3 удалённо по wifi. После настройки Raspberry Pi 3 можно выключить вписав в командной строке (в программе LXTerminal которую можно открыть двойным кликом по иконке программы) команду sudo halt или нажав соответствующие кнопки выключения в графическом режиме, после окончательного выключения можно отключить питание и при следующей подаче питания Raspberry Pi 3 включиться с wifi. Теперь чтобы программировать Raspberry Pi 3 по wifi нужно выяснить какой у него ip адрес. Для того чтобы это сделать надо подать питание на Raspberry Pi 3, дождаться окончания загрузки ос, зайти в веб интерфейс маршрутизатора (вписав в строке браузера 192.168.1.1 или то что надо для входа в веб интерфейс, ввести логин и пароль), найти вкладку DHCP Leases или что то подобное, найти там строку с raspberry и ip адрес Raspberry Pi 3.
Далее нужно открыть программу PuTTY (если её нет то перед этим скачать (или ) и установить) поставить порт 22, соединение по SSH, вписать в поле "Host Name (or IP Adress)" ip адрес Raspberry Pi 3,
После чего нажать кнопку "Open" внизу окна, далее появиться чёрное окно с предложением ввести логин. По умолчанию логин "pi" - его надо ввести и нажать enter. Далее надо ввести пароль, по умолчанию "raspberry". При вводе пароля он не отображается - это нормально. После того как пароль введён невидимыми буквами нужно нажать enter и если всё было сделано правильно то мы получим доступ к Raspberry Pi 3 если нет то нужно повторить действия. После того как получен доступ к Raspberry Pi 3 можно его программировать, для начала нужно войти в папку "pi" для этого надо вписать команду
И нажать enter (после cd обязательно пробел).
Теперь можно открыть текстовый редактор nano. Nano - это специальный текстовый редактор который есть на большинстве ос на подобии Linux и в котором можно написать программу для Raspberry Pi. Для открытия этого редактора и одновременно с этим создания файла с названием "first" и расширением "py" нужно вписать команду
И нажать enter. Откроется редактор nano и можно заметь что его интерфейс немного отличается но в основном - это то же чёрное поле в которое надо вписывать команды. Т.к. мы хотим управлять портами ввода вывода общего (GPIO) то прежде чем запустить программу по управлению этими портами, нужно подключить к ним какое нибудь устройство чтобы можно было видеть что управление получилось. Надо также отметить что пины настроенные как выходы у Raspberry Pi могут выдавать очень небольшой ток (предполагаю что до 25мА) и учитывая что Raspberry Pi это всё таки не самое дешёвое устройство то настоятельно рекомендуется позаботиться от том чтобы нагрузка на выводы не была слишком большой. Маломощные индикаторные светодиоды, как правило, могут использоваться с Raspberry Pi т.к. им для того чтобы светиться достаточно небольшого тока. Для первого раза можно сделать приспособление с разъёмом, двумя встречно параллельно включёнными светодиодами и резистором с сопротивлением 220Ом включённым последовательно со светодиодами. Т.к. сопротивление резистора 220Ом, ток обязательно проходит через этот резистор и нет параллельных путей его прохода, напряжение на выводах 3.3В то ток не будет больше чем 3.3/220=0.015А=15мА. Подключить это можно к свободным GPIO например к 5 и 13 как на схеме
(распиновка взята с https://en.wikipedia.org/wiki/Raspberry_Pi), выглядеть это может примерно так:
После того как всё аккуратно и правильно подключено и есть уверенность в том что ничего не сгорит можно скопировать в редактор NANO первую простенькую программу на языке Python
Import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(5, GPIO.OUT)
GPIO.output(13, True)
GPIO.output(5, False)
time.sleep(1)
GPIO.output(13, False)
GPIO.output(5, True)
time.sleep(1)
GPIO.output(13, True)
GPIO.output(5, False)
time.sleep(1)
GPIO.output(13, False)
GPIO.output(5, True)
time.sleep(1)
GPIO.output(13, True)
GPIO.output(5, False)
time.sleep(1)
GPIO.output(13, False)
GPIO.output(5, True)
time.sleep(1)
GPIO.cleanup()
Потом нажать
После выхода из редактора NANO можно ввести команду
Sudo python first.py
После чего светодиоды помигают некоторое количество раз. Т.е. получилось управлять портами ввода вывода общего назначения по wifi! Теперь давайте рассмотрим программу и выясним как это получилось.
Строка:
Import RPi.GPIO as GPIO
Это подключение библиотеки "GPIO" для управления выводами.
Строка:
Это подключение библиотеки "time" для задержек.
Далее идёт установка режима GPIO:
GPIO.setmode(GPIO.BCM)
Конфигурация выводов 5 и 13 как выходы:
GPIO.setup(13, GPIO.OUT)
GPIO.setup(5, GPIO.OUT)
Установка логической единицы на выводе 13, установка логического нуля на выводе 5:
GPIO.output(13, True)
GPIO.output(5, False)
Задержка
Установка логического нуля на выводе 13, установка логической единицы на выводе 5:
GPIO.output(13, False)
GPIO.output(5, True)
Переводит все выводы в исходное состояние и программа завершается. Т.о. можно управлять любыми свободными пинами по wifi и если сделать питание 5В от аккумулятора то уже можно сделать какого нибудь автономного робота или устройство не привязанное проводами к чему либо стационарному. Язык программирования Python (питон) отличается от си подобных языков, например вместо точки с запятой, для завершения команды, в питоне используется перевод строки, вместо фигурных скобок используется отступ от левого края который делается клавишей Tab. В общем Python это очень интересный язык на котором получается легко читаемый простой код. После того как работа (или игра) с Raspberry PI 3 закончена можно его выключить командой
И после полного выключения убрать питание. При подаче питания Raspberry PI 3 включается и с ним снова можно работать (или играть). Заказать Raspberry pi 3 можно по ссылке http://ali.pub/91xb2 . О том как делается настройка Raspberry PI 3 и управление его пинами можно посмотреть на видео:
После успешного мигания светодиодами можно приступить к полномасштабному изучению данного компьютера и созданию проектов используя возможностями Raspberry PI 3 которые ограничены лишь вашим воображением!
До сих пор Raspberry Pi остается одним из самых популярных технологических гаджетов.На эту плату Вы можете установить практически любую операционную систему. Но сегодня мы поговорим о том, как писать программы для этой платы без операционной системе, пользуясь лишь аппаратными средствами.
В чем подвох?
На первый взгляд задача кажется тривиальной: скачиваем keil, создаем проект… Но все не так просто. Все среды программирования(keil, IAR, Atolic) поддерживают максимум ARM9.У нас же ARM11. Это связано с негласным правилом, что на голом железе пишут до ARM9, а после на Линуксе. Но все-таки есть одна лазейка: arm-none-eabi-gcc поддерживает любой ARM.Вторая проблема заключается в том, что под данный процессор(BCM2835) нет никаких конфигурационных файлов, header"ов и т.д. Здесь нам на помощь придет загрузчик Raspberry Pi. И ничего, что он пропритетарный. Он выполняет две функции: инициализирует процессор и его периферию, а также передает управление ядру kernel.img. Мы просто замаскируем свою программу под ядро и загрузчик её запустит.
Что нам понадобится?
1) Сама Raspberry Pi, карта памяти к ней и питание.2) Даташит на процессор
3) Компьютер с установленным Linux (но может быть можно и на Винде. Не знаю, не пробовал).
4) Кросскомпилятор, установленный на компьютере из пункта 3. Я использую arm-none-eabi-gcc
5) Содержимое этой папочки.
Приготовления.
Нам нужно отформатировать карту памяти в FAT16 и закинуть на нее содержимое этой папки . Это загрузчик плюс ядро. Затем удаляем оттуда файлы kernel.img и kernel_emergency.img. Это ядро Linux, а оно нам не нужно.Первая программа.
Теперь мы можем приступить к написанию первой программы. Создаем файл main.c и пишем следующий кодint main (void) { while(1) { } } void exit (void) { while(1) { } }
Как видите, эта программа ничего не делает. Функция exit зачем-то нужна компилятору.
Теперь соберем её.
arm-none-eabi-gcc -O2 -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s -nostartfiles main.c -o kernel.elf
arm-none-eabi-objcopy kernel.elf -O binary kernel.img
Полученный файл kernel.img кидаем на карту памяти. Готово!
GPIO
Вряд ли Вас устроит программа, которая не будет делать абсолютно ничего. Сейчас попробуем зажечь лампочку.Для начала объявим адрес, по которому лежит GPIO(это можно прочитать в даташите).
#define GPIO_BASE 0x20200000UL
И объявим переменную, которая определяют, что порт настроен на выход (GPIO_GPFSEL1) и переменную, подающую низкий уровень(то есть лампочка горит) на порт (GPIO_GPCLR0).
#define GPIO_GPFSEL1 1
#define GPIO_GPCLR0 10
Ну и наконец модифицируем главную функцию для зажигания лампочки:
volatile unsigned int* gpio; int main(void) { gpio = (unsigned int*)GPIO_BASE; gpio |= (1 << 16); gpio = (1 << 16); while(1) { } }
Собираем, прошиваем и радуемся.
В следующей части попробуем поиграться с таймерами и прерываниями.
Как-то я писал о том, что планирую использовать 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 цифровых программно управляемых выводов
Примечание: Это знакомые понятия для тех, кто сталкивался с программированием микроконтроллеров. Для тех, кто не сталкивался и на данном этапе пока желает просто программно выводить "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 GPIOGPIO.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 - одноплатный компьютер размером 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.
Теперь, если выключить питание, отключить монитор, мышь и клавиатуру, и снова включить питание, наш светофор начнет работать в автономном режиме!
Видео работы светофора:
