Вредоносное ПО (malware) - это назойливые или опасные программы,...
Вычислительных возможностей платы Raspberry Pi 3(далее по тексту Rpi3) более чем достаточно для разработки программ сразу в целевой системе. Однако процесс разработки можно ускорить и сделать более комфортным, если разрабатывать программное обеспечение для Rpi3 на своем персональном компьютере.
В данной статье я собираюсь описать процесс настройки кросс-компиляции в Eclipse под Windows. Также будет описана настройка Eclipse для работы с удаленной системой Raspbian на Rpi3.
Если вы впервые сталкиваетесь с Eclipse, то установить последнюю версию можно по ссылке Eclipse CDT .
Виртуальную машину Java, необходимую для работы Eclipse, можно загрузить по ссылке JRE .
После установки указанных выше компонентов интегрированная среда разработки Eclipse CDT сможет быть запущена на вашем компьютере. В качестве вспомогательных утилит будем использовать msys из пакета MinGW, поэтому необходимо также загрузить MinGW .
Осталось установить инструментальные средства для кросс-компиляции программ.
Для этого необходимо их загрузить по следующей ссылке toolchain .
На указанном сайте также имеется инструкция на английском языке по установке инструментария tutorial .
После установки инструментария в указанном вами каталоге будут находится также дополнительные утилиты в подкаталоге TOOLS:
- – утилита для записи образа операционной системы Rpi3 на карту памяти.
- SmarTTY – консольный SSH – клиент, позволяющий установить соединение с платой по протоколу SSH. Помимо стандартных функций имеет возможность загрузки файлов на плату из меню утилиты.
- UpdateSysroot – командный файл Windows , запускающий процесс синхронизации файловой системы sysroot платы и инструментария.
Если вы только что приобрели плату Rpi3 и еще не успели установить операционную систему на карту памяти, то утилита WinFlashTool поможет вам это сделать.
Необходимо загрузить с официального источника образ операционной системы Raspbian .
Дальше распакуйте загруженный образ, установите карту памяти в кард-ридер и запишите на нее с помощью WinFlashTool образ операционной системы.
Настройка беспроводной сети WLAN на плате RPi3 описана в моей предыдущей статье.
С помощью утилиты SmarTTY установите соединение с платой. Это необходимо для исключения проблем во время настройки удаленного соединения в Eclipse.
Создайте новое соединение, указав IP -адрес платы, логин и пароль для входа (значения по-умолчанию для логина и пароля pi и raspberry соответственно).
Теперь нужно провести синхронизацию файловой системы sysroot. Для чего это нужно?
Представьте ситуацию, когда вы установили самую последнюю версию образа Raspbian и не выполнили синхронизацию.
В новой версии были добавлены или изменены заголовочные файлы и файлы библиотек. Работая с кросс-компилятором вы используете старые, не идентичные с последней версией системы, заголовочные и библиотечные файлы из каталога sysroot. Поэтому нет никакой гарантии, что успешно собранная на компьютере программа будет работать внутри платы RPi3.
Запускаем скрипт UpdateSysroot на выполнение и наблюдаем за обновлением файлов на компьютере (это может занять несколько десятков минут).
Настало время настроить удаленное соединение с платой Rpi3 в Eclipse . Запускаем Eclipse CDT , выбираем в главном меню пункт Window->Show View->Other… В открывшемся окне выбираем «remote systems».
После этого в нижней части экрана появиться новая вкладка «Remote Systems». В этой вкладке необходимо определить новое соединение, нажав на первую кнопку справа.
В открывшемся окне выбираем тип соединения «Linux».
После проделанных манипуляций в закладке «Remote Systems» появится новое соединение, которое имеет подразделы:
- Sftp Files – в этом разделе можно просматривать содержимое удаленной файловой системы. Также возможно выполнять копирование файлов с помощью перетаскивания (Drag and Drop) из локального проекта на удаленную машину и обратно.
- Shell Processes – раздел позволяет просмотреть запущенные на удаленной машине процессы.
- Ssh Shells – в этом разделе можно открыть новый SSH -терминал и вводить команды прямо из Eclipse. Надобность в отдельной утилите при этом отпадает.
Таким образом с помощью закладки «Remote Systems» мы сможем копировать собранные на компьютере программы в файловую систему Rpi3 , запускать их на выполнение через Ssh Shells и удалять ненужный процесс в разделе Shell Processes .
Настало время создать новый проект в Eclipse и написать простую демонстрационную программу.
Создаем новый проект из главного меню File->New->C Project.
Для сборки я использую собственный , поэтому тип проекта нужно выбрать Makefile project->Empty Project
Далее вы можете просто скопировать мой Makefile в буфер клавиатуры (Ctrl+C) и вставить его в пустой проект Rpi3_Project (Ctrl+V).
Открыв Makefile в первой его строке после комментария вы увидите список используемых целей:
.PHONY: test project all clean
- test – проверяет установлен ли в системе кросс-компилятор arm-linux-gnueabi-gcc и утилита make.
- project - создает структуру каталогов внутри проекта.
- all — производит сборку проекта.
- clean — производит очистку проекта от временных файлов(в том числе исполняемого).
Теперь нужно убедиться в наличии инструментальных средств. Для этого необходимо выполнить команду make test.
Но сначала нужно добавить все четыре цели в закладку Make Target в правой части экрана.
Двойным щелчком мыши по цели test запускаем ее на исполнение и видим в окне Console примерно следующее:
Если сообщение не было выведено в консоль не смотря на то, что инструментарии arm-linux-gnueabihf и MinGW были ранее установлены, то это может означать только то, что не прописаны пути к инструментам в системной переменной Path . Необходимо добавить в Path путь к каталогу MinGW/msys/1.0/bin и каталогу bin пакета arm-linux-gnueabihf.
Теперь создадим структуру каталогов внутри проекта двойным щелчком на цели project (make project).
Makefile организован таким образом, что для компиляции исходных файлов их названия должны быть добавлены в переменную SRC, все остальные исходники не будут компилироваться даже если они расположены внутри каталога /src.
Структура каталогов проекта такова:
- bin – каталог, содержащий исполняемый файл после сборки.
- Debug – каталог с отладочной версией программы, которая не содержит оптимизации кода и содержит отладочную информацию.
- Release – каталог с финальной версией программы, которая содержит оптимизированный код и не содержит отладочной информации.
- inc – каталог для заголовочных файлов.
- obj – содержит временные файлы сборки проекта, имеет подкаталоги Debug и Release.
- src – исходные файлы проекта.
С помощью данного Makefile можно компилировать исходные файлы, написанные на таких языках программирования как C , C++, Assembler. При этом можно использовать все доступные языки программирования для создания одной программы.
В каталоге /src создадим новый исходный файл main.c, добавим в него следующие строки:
#include
#include int main (int argc , char * * argv ) ; int main (int argc , char * * argv ) printf ("Welcome to the Raspberry Pi 3 programming\n" ) ; return 0 ; } /* main */ |
Проверим, чтобы переменная SRC содержала название исходного файла main.c .
Дальше выполним сборку проекта, запустив цель all .
Теперь можно скопировать полученный исполняемый файл в домашний каталог на целевой плате используя перетаскивание файла мышью.
Сделаем правый клик мышью на разделе Ssh Shells для открытия контекстного меню, в котором необходимо выбрать Launch Shell . Откроется новая вкладка Remote Shell , в поле Command которой можно вводить команды оболочки.
Установим права доступа для скопированного файла Rpi3_Project с помощью команды:
sudo chmod 777 Rpi3_Project
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 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.
Теперь, если выключить питание, отключить монитор, мышь и клавиатуру, и снова включить питание, наш светофор начнет работать в автономном режиме!
Видео работы светофора:
Как-то я писал о том, что планирую использовать 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 .
In this post, I’ll give a quick overview of what a Python program is, what they can be used for, and finally, how to write and run a simple program on the Raspberry Pi.
What is a Python program?
The Python programming language actually started as a scripting language for Linux. Python programs are similar to shell scripts in that the files contain a series of commands that the computer executes from top to bottom. Python is a very useful and versatile high level programming language, with easy to read syntax that allows programmers to use fewer lines of code than would be possible in languages such as assembly, C, or Java.
Compare a “hello world” program written in C vs. the same program written in Python:
Python programs don’t need to be compiled before running them, as you do with C programs. However, you will need to install the Python interpreter on your computer to run them. The interpreter is the program that reads the Python file and executes the code. There are programs like or Pyinstaller that can package Python code into stand-alone executable programs so you can run Python programs on computers without the Python interpreter installed.
What can a Python program do?
Like shell scripts, Python can automate tasks like batch renaming and moving large amounts of files. Using IDLE, Python’s REPL (read, eval, print, loop) function can be used just like a command line. However, there are more useful things you can create with Python. Programmers use Python to create things like:
- Web applications
- Desktop applications and utilities
- Special GUIs
- Small databases
- 2D games
Python also has a large collection of libraries, which speeds up the development process. There are libraries for everything you can think of – game programming, rendering graphics, GUI interfaces, web frameworks, and scientific computing.
Many (but not all) of the things you can do in C can be done in Python. Computations are slower in Python than in C, but its ease of use makes Python an ideal language for prototyping programs and applications that aren’t computationally intensive.
How to create and run a program in Python
We will only cover the basics of writing and executing a Python program here, but for a great tutorial covering everything a programmer needs to know about Python, you might want to check out the bookLearning Python 5th Ed. (O’Reilly) by Mark Lutz .
Python 2 and Python 3 come pre-installed on Raspbian, but to install it on another Linux OS or to update it, simply run sudo apt-get install python3 or sudo apt-get install python. To access Python from the command prompt, type “python ” or “python3 ” depending on which version you want to use. This opens up the Python REPL (read-eval-print-loop), from which you can enter Python commands just like you use the command line. Use Ctrl-D to exit the REPL:
Our first program in Python will be the standard “hello world” program. To begin, enter sudo nano hello-world.py at the command prompt to open the nano text editor and create a new file named hello-world.py .
Enter this code into nano, then press Ctrl-X to exit and save the file:
All Python program files will need to be saved as “.py ” file types. You can write the program in a text editor such as notepad or notepad++ as long as you save the file with a “.py ” extension.
To run the program without making it executable, navigate to the location where you saved your file, and type python hello-world.py .
We can make the hello-world.py file executable by entering chmod +x hello-world.py at the command prompt. Now, all we need to do to run the program is enter: ./hello-world.py.
Here are some additional resources that will help you make the most out of programming in Python:
Hopefully you found this post useful. If you have any questions, feel free to leave a comment below. Also, if you know someone who would enjoy this article, please share it! You can also get updates when ever we post a new article by entering your email address in the subscribe box below…
