8-900-374-94-44
[email protected]
Slide Image
Меню

Raspberry pi 3 программирование gpio – GPIO в Raspberry PI — первое знакомство и программирование

Содержание

Простое программирование на Raspberry Pi для новичков

Содержание

  • Python – это основной язык Raspberry Pi
  • Программирование на других языках под Raspberry

Программирование 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;
  • наличие обширной, хорошо документированной официальной библиотеки, которая уже включена в пакет;
  • простота языка и т. д.

Примеры кода на Python для Raspberry

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

Вместо этого будет рассмотрено, насколько легко можно программировать "Малину". Для примера возьмем Raspberry Pi 3 GPIO программирование. Сделаем предположение, что в наличии имеется все необходимое: провода, светодиод, резистор и прочее, а также присутствует понимание распиновки – нумерации пинов. Также предположим, что светодиод подключен к 11 порту.

Написанный ниже код включает лампочку на 5 секунд, а затем выключает ее:

# вначале подключим необходимую библиотеку

import RPi.GPIO as GPIO

# также понадобится библиотека, которая отвечает за ожидание (она нужна, чтобы установить интервал включения и выключения лампочки)

import time

# чтобы запустить GPIO, понадобится выполнить следующую функцию

GPIO.setmode(GPIO.BOARD)

# теперь Python знает о GPIO, и ему можно указать на то, с каким портом нужно будет работать и что он должен делать (в данном случае – 11-м и он будет работать на выход)

GPIO.setup(11, GPIO.OUT)

# далее включим лампочку на 5 секунд (11 – номер порта, а 1 – значит true)

GPIO.output(11, 1)

time.sleep(5)

# теперь выключим (0 – значит false)

GPIO.output(11, 0)

Указанный код можно скопировать, вставить в документ и сохранить его с расширением .py, расположив, например, в домашней директории. Затем его нужно запустить командой: python ~./имя_файла.py.

Если все работает, то оборудование исправно.

Следует отметить, что, если вы плохо понимаете вышеуказанный код, обратитесь к документации и изучите основы программирования на Python, а также библиотеку GPIO. А если у вас есть хотя бы базовое понимание любого ЯП, то осознаете, что приведенный пример предельно прост.

Программирование на других языках под Raspberry

Программирование на C для Raspberry Pi или на других языках программирования почти ничем не отличается от того, что предполагает написание кода под другими платформами. Единственное – необходимы специальные библиотеки.

Библиотека WiringPi для работы с GPIO

Если интересует Raspberry Pi программирование на C/С++ и работа с GPIO, то требуется установить в систему непосредственно сам gcc, а затем библиотеку wiringPi – ее можно найти на GitHub. В описании к ней присутствует мануал по использованию.

Следует отметить, что для установки библиотек из GitHub, требуется утилита GIT. Если в системе ее нет, понадобится поставить из репозитория (полное имя: git-core).

Программирование "Малины" при помощи Java

Желающие программировать Raspberry Pi на Java, должны обратить внимание на Pi4J – библиотеку, которая предназначена специально для работы с "Малиной". Загрузить и узнать о ее особенностях можно на официальном сайте проекта.

Программирование Raspberry Pi для детей

Интересно то, что изначально "Малина" разрабатывалась непосредственно для обучения детей программированию. Создатель этого устройства заметил, что уровень понимания функционирования компьютеров у современных студентов значительно ниже, чем у тех, кто учился в 90-х. Он связал это с тем, что вычислительные устройства стали предельно просты: если раньше увлеченным электроникой детям и подросткам приходилось разбираться в командах терминала и даже самостоятельно писать код, теперь все делается посредством нажатия на пару кнопок.

Поэтому, естественно, предусмотрено визуальное программирование Raspberry Pi. В частности, для этого применяется язык Scratch со специальным сервером – GPIOSERVER. В Сети существует множество мануалов, которые помогают освоиться с соответствующими программами, поэтому рассматривать их смысла нет.

Перечисленными языками не ограничиваются возможности "Малинки". С ней можно взаимодействовать в том числе и при помощи PHP, Ruby, Perl и прочих ЯП. Почти под каждый популярный язык существуют хоть и не официальные, но зато рабочие и достаточно функциональные библиотеки. Однако опять следует упомянуть, что лучше для программирования Raspberry использовать именно "Пайтон".

myraspberry.ru

Распиновка GPIO на Raspberry Pi 3

RPi – компьютер, который получил столь высокую популярность во многом благодаря наличию встроенного интерфейса ввода/вывода. Используя его, можно создавать всевозможные гаджеты: от простых метеостанций и портативных игровых приставок до систем умного дома. У Raspberry Pi 3, конечно, тоже имеется GPIO. И он мало чем отличается от тех, который присутствует в других моделях.

Чтобы работать с GPIO Raspberry Pi 3, необходимо знать его схему. Собственно, это является самым важным. Из текста ниже, в свою очередь, вы узнаете о том, какие пины за что отвечают. А, чтобы иметь лучшее представление об устройстве GPIO, рекомендуется скачать соответствующую схему, выполненную в графике.

Что такое GPIO и для чего он нужен?

Новичкам будет полезно узнать о том, что собой представляет GPIO. Это интерфейс, который предназначен для обеспечения связи между компонентами компьютера. В случае с "Малиной" он необходим для работы основной системы с дополнительными компонентами, которые называются модулями.

Пины в GPIO могут выполнять 3 функции:

  • подача электричества определенного напряжения;
  • заземление;
  • прием/отправка сигналов.

Интересно то, что за вход и выход в интерфейсе могут отвечать одни и те же контакты. По крайней мере это справедливо для RPi. То, как они себя должны вести, определяется программой.

Как устроено GPIO на RPi3?

Теперь можно перейти к вопросу, который касается того, какая распиновка GPIO имеется на Raspberry Pi 3. В первую очередь необходимо сказать, что общее количество пинов на соответствующей панели равняется 40. Каждый из них имеет свой номер.

Все они подразделяются на 3 группы. К первой относятся питающие (на англоязычных схемах маркируются как Power) – они подают электричество в 3,3 и 5 Вольт. При этом у разных контактов данного назначения различное напряжение. Это обязательно следует учитывать при подключении модулей.

Ко второй – заземляющие (могут именоваться RND или Ground). Они нужны, чтобы отводить электричество, тем самым обеспечивая безопасное использование.

К третьей – порты (имеют обозначение BCM). Именно они служат теми контактами, которые могут принимать и отправлять сигналы. Пользователь может подключать модули к любым из них. Самое главное – чтобы было удобно обеспечивать питание подсоединённых компонентов.

Разобравшись с тем, какие типы контактов присутствуют в GPIO, можно перейти непосредственно к тому, какие из них конкретно за что отвечают. Самый простой способ освоить распиновку – это изучить схему. Но если такой возможности нет, можно обойтись и описанием.

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

  • левый нижний – 1;
  • левый верхний – 2;
  • нижний во втором ряду – 3;
  • верхний во втором ряду – 4 и т.д.

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

Питающие на 3,3 Вольта – 1 и 17, а на 5 Вольт – 2 и 4 (они находятся рядом). Заземляющие внизу – 9, 25 и 39, заземляющие вверху – 6, 14, 20, 30 и 34. Все остальные контакты – это порты (BCM).

Особенности нумерации GPIO

Чтобы начать использование GPIO в Raspberry Pi 3, необходимо знать какие существуют особенности нумерации контактов у данного интерфейса. Важно понимать, что в процессоре "Малины" не записаны номера пинов, которые не работают на вход/выход, то есть не являются портами.

Поэтому при управлении GPIO на Raspberry Pi 3 необходимо знать нумерацию BCM. Она в значительной степени отличается от той, которая рассмотрена в разделе выше. Так, 3 контакт (он является портом) имеет номер BCM2. Именно такой следует указывать при написании кода.

Понятно, что из-за этого может возникнуть путаница. Ввиду этого на Raspberry Pi 3 рекомендуется использовать Wiring Pi. Это специальная библиотека, которая имеет собственную нумерацию. Так, например, 3 порт (который является BCM 2) определяется как WiringPi 8. Возможно, это покажется еще более нелогичным. Но после ознакомления с соответствующей схемой все встанет на свои места.

Что нужно знать о GPIO RPI3?

Модули возможно подключать к абсолютно любым портам GPIO "Малины", и они будут нормально работать. Но важно знать, что в системе есть пара контактов, которые зарезервированы системой для особых целей. Ими являются BCM 0 и BCM 1 (их номера на обычной схеме – 27 и 28). Они предназначаются специально для установки плат расширения. Поэтому при возможности их не нужно использовать для подключения других модулей.

Еще один важный момент – осторожное использование питания через GPIO Raspberry Pi 3. Ток на внешние устройства через "Малину" может подаваться с силой до 50 мА. Это достаточно много для столь небольшого девайса. Поэтому подавать ток под такой силой нужно только по крайней необходимости. В противном случае можно не только испортить модуль, но и процессор самой RPi.

Купить
Raspberry PI

Проверенный поставщик

MyRaspberri.ru рекоммендует

Как можно взаимодействовать с GPIO?

Работать с GPIO "Малины" можно посредством языков программирования. Вариантов здесь существует много. Самый лучший для GPIO Raspberry Pi 3 – Python. Это связано с тем, что для этого одноплатника данный ЯП является "родным". Но с не меньшим успехом с интерфейсом возможно взаимодействовать и посредством C/C++ и даже PHP или Basic. Язык каждый выбирает под себя.

Как возможно убедиться, распиновка GPIO на RPi3 не является какой-то сложной. Единственное – по неопытности в ней можно немного запутаться. Чтобы этого не происходило, рекомендуется загрузить на компьютер схему расположения контактов. При этом лучше не одну, а несколько (обычную, BCM и WiringPi). Так будет удобно и подключать модули, и взаимодействовать с ними через программные инструменты.

myraspberry.ru

Установка и настройка Python и RPI.GPIO в Raspbian для Raspberry Pi

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. Эти порты позволяют собирать данных с датчиков, управлять двигателями, ключами, реле и прочими устройствами с помощью программы.

В первую очередь нужно скачать архив с официального сайта https://sourceforge.net/projects/raspberry-gpio-python/files/?source=navbar. На странице можно увидеть большое количество версий библиотеки. Нужно выбрать самую свежую версию.

Архив будет загружен в папку загрузки по адресу /home/pi/Downloads. Нужно зайти в нее, найти скачанный архив, нажать правую кнопку мыши и выбрать во всплывающем меню Extract Here.

Эта команда разархивирует библиотеку в папку, в которую помещен  архив. Рядом с ним будет добавлена новая папка с названием RPi.GPIO-0.6.3.

Следующим шагом нужно установить python-dev. Запускается терминал и в него вводится команда

sudo apt-get install python-dev

Будет задан вопрос «Do you want to continue? [Y/n]», нужно нажать «Yes» и Enter.

В окне высветится отчет, который сообщает об успешно проведенной установке.

Чтобы установить библиотеку RPi.GPIO, нужно не закрывая перейти в папку, которая была распакована до этого.

cd /home/pi/Downloads/RPi.GPIO-0.6.3

Затем нужно запустить команду:

python setup.py build

На экране появится отчет о выполнении.

После этого нужно запустить установку библиотеки с помощью команды

sudo python setup.py install

После успешной установки на экране появится новый отчет.

Библиотека установлена, можно начинать работать.

Помимо вышеописанной библиотеки RPi.GPIO существуют и другие. Для доступа к GPIO контактам используется также библиотека WiringPi. Эта библиотека написана на языке C, используется в средах C, C++ и RTB (BASIC) и других. Она создавалась схожей с библиотекой Wiring на Ардуино.

Для программирования и настройки контактов вместе с библиотекой используется утилита gpio для командной строки. Она позволяет записывать и считывать данных с портов и управлять ими.

 

arduinomaster.ru

Как работает GPIO на Raspberry Pi

 

Raspberry Pi не был бы таким популярным, если в нём не предусмотрели GPIO. Этот интерфейс ввода/вывода позволяет сделать из одноплатника практически все что угодно – от удаленных управляемых машинок до систем "умного дома".

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

Особенности GPIO "Малины"

В первую очередь необходимо рассмотреть ключевые особенности этого интерфейса. И самое главное в GPIO Raspberry Pi – это pings (пины). Именно они используются для связи одноплатника с периферией.

В совокупности у "Малины" есть 26 GPIO (портов), однако самих элементов больше:

  • 2 из них отвечают за подачу напряжения в 5 Вольт;
  • 2 – 3,3 Вольта;
  • 8 применяются для заземления;
  • 2 используются исключительно для подключения расширений.

Все они выстроены в 2 ряда. Если расположить плату горизонтально и так, чтобы интерфейс оказался вверху, то к первой паре элементов можно подключать (запитывать) устройства, требующие напряжения в 5 Вольт. Снизу, в свою очередь, находится 1 на 3,3, а второй такой же располагается в этом же ряду, примерно посередине – между 22 и 10 портами.

Чтобы ознакомиться с распиновкой GPIO Raspberry следует изучить схему. Её рекомендуется загрузить на компьютер, чтобы при необходимости можно было быстро обратиться к данной информации – заучить сразу расположение всех элементов не получится.

Через что возможно взаимодействовать с GPIO Raspberry

Работать с GPIO Raspberry Pi можно практически через любой инструмент. К сегодняшнему дню созданы соответствующие библиотеки почти под все распространенные языки программирования. С GPIO Raspberry Pi возможно взаимодействовать даже через PHP и JavaScript (node.js).

Однако человеку, который только начинает знакомиться с "Малиной", рекомендуется пробовать взаимодействовать с данным интерфейсом посредством Python. Это обусловлено, во-первых, что для GPIO в Raspbian уже предустановлена соответствующая библиотека для Пайтона, а, во-вторых, этот ЯП является основным для рассматриваемого одноплатника.

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

Купить
Raspberry PI

Проверенный поставщик

MyRaspberri.ru рекоммендует

Дополнительные утилиты для работы с GPIO

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

К таким утилитам, в частности, относятся: quck2wire-gpio-admin и WiringPi GPIO utility. Первая из них является более функциональной.

Если требуется прямой доступ к портам, также можно инсталлировать еще и PRIO. Расписывать принцип его работы и вышеуказанных программ нет смысла, так как всю необходимую информацию возможно получить из официальной документации.

Следует отметить, что любые из указанных программ возможно легко найти в репозитории Raspbian.

Управление GPIO "Малины" через Python

И теперь самое интересное: как выполняется управление GPIO Raspberry Pi через Пайтон.

Абсолютно отсутствует необходимость рассказывать о самом языке Python и подробно описывать библиотеку. Эту информацию легко найти на официальных сайтах соответствующих проектов – лучше изложить материал, чем там, крайне тяжело.

Однако есть смысл просто продемонстрировать некоторые принципы взаимодействия с GPIO. Конечно, перед написанием кода следует подключить устройство, с которым нужно работать к GPIO.

Первое, что потребуется сделать – это подключить библиотеку, делается это так: import PRi.GPIO as GPIO.

Далее нужно дать интерпретатору понять, что обращение к портам будет выполняться по их названиям. Это выполняется инструкцией: GPIO.setmode(GPIO.BCM). Предварительно также рекомендуется сбросить текущее состояние интерфейса (мало ли каково оно, хотя это и не критично) – GPIO.cleanup().

Далее можно сконфигурировать порты на выход и вход. Первое делается так: GPIO.setup(НОМЕР_ПОРТА, GPIO.OUT), а второе – GPIO.setup(НОМЕР_ПОРТА, GPIO.IN).

То есть, как можно убедиться, абсолютно ничего сложного в работе с GPIO нет. Главное – знать название портов (возможно почерпнуть из схемы) и функции, предусмотренные библиотекой.

Итог: что понадобится для работы с GPIO

В завершении следует резюмировать все вышесказанное. Если вы хотите работать с GPIO, то вам потребуется следующее:

  • сама "Малина";
  • установленная на ней Raspbian;
  • внешнее устройство, управление которым вас интересует;
  • умение работать с документацией.

Даже с нуля и без знания ЯП в GPIO Raspberry возможно более или менее освоиться за пару вечеров. Работать с интерфейсом "Малины" очень просто. Это связано с тем, что данный одноплатник создавался, в том числе с целью обучения людей взаимодействия с компьютерами на уровне железа. Конечно, ничего сложного без глубоких знаний сделать не получится. Но так происходит всегда в процессе обучения. Со временем, с приобретением знаний и опыта можно будет реализовывать все более и более интересные вещи.

myraspberry.ru

Использование GPIO из Python на Raspberry Pi / Habr

Делюсь своим опытом, полученным при изучении задачи вынесенной в заголовок. В статье рассматриваются два варианта работы, которые можно использовать в Python-программах, обращающихся к портами GPIO Raspberry Pi.

Порты GPIO Raspberry Pi выглядят следующим образом:

Одним из вариантов работы с GPIO является интерфейс Sysfs. Подробнее о Sysfs интерфейсе GPIO здесь. В этом случае для обращения к портам GPIO используются операции чтения и записи файлов. Для использования конкретного вывода его нужно зарезервировать и установить направление на вход или на выход. После окончания работы с портом его нужно освободить, чтобы другие процессы могли его использовать.

Резервирование порта (XX — номер нужного порта):

$ echo XX > /sys/class/gpio/export

При успешном резервировании появляется новая папка по адресу /sys/class/gpio/gpioXX/. Установка направления выполняется так:

$ echo "out" > /sys/class/gpio/gpioXX/direction

Или так:

$ echo "in" > /sys/class/gpio/gpioXX/direction

Установка высокого и низкого уровней для порта, настроенного на выход выполняется так:

$ echo 1 > /sys/class/gpio/gpioXX/value
$ echo 0 > /sys/class/gpio/gpioXX/value

Определение состояние порта, настроенного на вход делается так:

$ cat /sys/class/gpio/gpioXX/value

Освобождение порта после окончания его использования:

$ echo XX > /sys/class/gpio/unexport

Для упрощения работы с GPIO через интерфейс Sysfs мне встретились две утилиты. Одна из них WiringPi GPIO utility, другая quick2wire-gpio-admin.

Основная задача, решаемая этими утилитами — это предоставление возможности работы с GPIO от имени непривилегированного пользователя. При этом WiringPi GPIO utility более функциональна.

Я для работы с GPIO остановился на пакете RPIO (на момент написания последней была версия 0.10.0). Этот пакет работает с портами GPIO напрямую, обращаясь к регистрам BCM2708 через специальное устройство /dev/mem. Что такое RPIO:

Advanced GPIO for the Raspberry Pi. Extends RPi.GPIO with PWM, GPIO interrups, TCP socket interrupts, command line tools and more

RPIO позиционируется как улучшенный и расширенный вариант другого модуля, RPi.GPIO. В документации непосредственно на RPIO подробно рассмотрены только возможности, отсутствующие в RPi.GPIO, по этому за описанием общих для этих модулей функций нужно обращаться к документации RPi.GPIO, доступной здесь.

Устанавливается пакет следующей командой:

$ sudo pip install RPIO

Кроме python-модулей устанавливаюся две программы: rpio-curses и rpio. С их помощью можно, например, получить текущий режим и состояние GPIO и, при желании, изменить их. Так выглядит работа с rpio-curses:

Так можно получить информацию о системе:

$ rpio --sysinfo
000f: Model B, Revision 2.0, RAM: 512 MB, Maker: Qisda

Пример python-программы, использующей RPIO:

import RPIO
import time

NRF_CE = 24

# set up output channel with an initial state
RPIO.setup(NRF_CE, RPIO.OUT, initial=RPIO.LOW)

for i in range(10):
    RPIO.output(NRF_CE, 1)
    time.sleep(1)
    RPIO.output(NRF_CE, 0)
    time.sleep(1)

# reset every channel that has been set up by this program,
# and unexport interrupt gpio interfaces
RPIO.cleanup()

habr.com

hexvolt-блог: Raspberry Pi. Работаем с GPIO на Python

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

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


Предварительно я наладил удаленную работу с Raspberry Pi через SSH, чтобы каждый раз не подключать  монитор и клавиатуру. Поэтому в исходном состоянии у меня к 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 7 как выход
     GPIO.setup(8, GPIO.IN)        #конфигурируем GPIO 8 как вход

Примечание: именно после выполнения этой команды на GPIO 7 установится ровно 0 В, поскольку этот вывод больше не является входом и на нем нет "плавающего" потенциала.

С помощью необязательного параметра pull_up_down функции setup можно также настроить "подтяжку" вывода к питанию или к земле:
     GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_UP)           #подтяжка к питанию 3,3 В
     GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)   #подтяжка к земле 0 В
     GPIO.setup(8, GPIO.IN, pull_up_down=GPIO.PUD_OFF)        #режим по-умолчанию

4) Формируем и считываем сигналы
Формируем "1" и "0" на GPIO 7 и считываем сигнал с GPIO 8:

     GPIO.output(7, True)             #выводим на GPIO 7 логическую "1" (3.3 V)

     GPIO.output(7, False)            #выводим на GPIO 7 логический "0"
     signal = GPIO.input(8)           #считываем сигнал с GPIO 8 в переменную signal

5) Завершаем работу
После всех нужных операций корректно завершаем работу:
     GPIO.cleanup()

Выполнение этой операции приведет к возвращению всех выводов GPIO в первозданное состояние.

Примечание: если не выполнить эту операцию, то даже после закрытия программы и выхода из python, выводы GPIO останутся в том, состоянии, в котором они были на момент завершения. Это может быть чревато тем, что при попытке повторно поработать с этими выводами будет возникать сообщение, о том, что вывод уже используется: "RuntimeWarning: This channel is already in use, continuing anyway."

Весь пример целиком:
     import RPi.GPIO as GPIO       #подключаем библиотеку
     GPIO.setmode(GPIO.BCM)    #устанавливаем режим нумерации
     GPIO.setup(7, GPIO.OUT)     #конфигурируем GPIO 7 как выход
     GPIO.setup(8, GPIO.IN)         #конфигурируем GPIO 8 как вход
     GPIO.output(7, True)               #выводим на GPIO 7 логическую "1" (3.3 V)

     GPIO.output(7, False)              #выводим на GPIO 7 логический "0"
     signal = GPIO.input(8)             #считываем сигнал с GPIO 8 в переменную signal
     GPIO.cleanup()                        #завершаем работу с GPIO



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


Итак, программное циклическое переключение цифровых выводов GPIO осуществляется с максимальной частотой ~27 кГц. На второй картинке видно, что в каждом из устойчивых состояний ("1" и  "0") вывод может находится в течение ~ 18-20 мкс. Получить импульсы меньшей длительности с помощью используемых в статье программных средств нельзя.

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

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

Как можно применить все это на практике? Зачем выводить "1" или "0" на GPIO? Например, можно помигать светодиодами! Например, можно управлять силовой нагрузкой и включать / выключать любые бытовые приборы, работающие от сети 220 В. Для этого понадобится Raspberry Pi и всего 7 деталей. Схема такого программного "выключателя" приведена ниже:

Примечание: микросхема-оптодрайвер MOC3041M имеет гальваническую развязку силовых цепей от слаботочных, поэтому она является "барьером безопасности" между Raspberry и сетью 220 В, выход ее из строя не повредит Raspberry. Конденсатор C8 должен быть высоковольтным и выдерживать напряжение ~400 В.

Данная схема может коммутировать токи до 16А. Она полностью отлажена, проверена на практике и занимает очень мало места (к сожалению, у меня не сохранились фото устройства, где она используется). Подача "1" на GPIO 7 Raspberry Pi приведет к срабатыванию оптодрайвера и открытию симистора V2, который начнет пропускать через себя ток, идущий от сети 220 В к силовой нагрузке. Прибор включается. Как только на GPIO 7 возникает "0" - симистор V2 закрывается и цепь нагрузки размыкается. Прибор выключается. Все просто!

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

На этом все. В следующем посте о Raspberry постараюсь описать работу с UART и SPI.

hexvolt.blogspot.com

Проекты Raspberry Pi на Python c GPIO для DIY проектов

В этой статье мы поговорим о том, как подключать к Raspberry Pi датчики и другие внешние устройства через GPIO порты платы. Для работы будем использовать Python и библиотеки. Если вы новичок в работе с распбери, рекомендуем прочитать статью об установке Python и библиотек для Raspberry Pi.

Подключение внешних устройств к Raspberry Pi

Отличие Raspberry Pi от Arduino

Среди любителей радиотехники и электроники каждый слышал о существовании таких устройств как Arduino и Raspberry Pi. Обе платы используются для решения схожих  задач, оба прекрасно подходят для начинающих. Но по сравнению с Ардуино Raspberry – это многофункциональный компьютер, на котором может запускаться операционная система.

Из основных отличий можно выделить тактовую частоту – Raspberry работает в 40 раз быстрее Ардуино, и объем оперативной памяти – у Raspberry памяти больше примерно в 128000 раз. За счет простоты управления и использования разрабатывать аппаратные проекты на Ардуино  предпочтительнее. Ардуино может работать с любыми датчиками или чипами, а Raspberry Pi не такая гибкая, для работы с датчиками требуются дополнительные аппаратные устройства. Raspberry Pi очень требовательна к питанию, напряжение должно быть строго 5 В на входе, в то время как для ардуино рекомендуемое питание 7-12 В, которое стабилизируется до 5 В.

Важное отличие заключается в среде, в которой пишется программа. С Arduino IDE работать намного проще, чем с Linux. Установка библиотек для написания программы требуется для обеих систем, но код на Ардуино будет написан проще и короче.

Raspberry Pi возможно использовать в режиме многозадачности, как обычный компьютер. Одновременно может работать несколько программ в фоновом режиме.

Для расширения возможностей можно совместно использовать обе платы. Для управления датчиками и сенсорами использовать Ардуино, а сложные вычислительные задачи оставить для Raspberry Pi.

Описание GPIO

Количество портов в более старых и новых моделях Raspberry Pi отличается –model A и model B оснащены 26 выводами общего назначения GPIO, в следующих версиях количество выводов увеличено до 40.

Существует несколько видов обозначений выводов:

  • BCM – нумеруются выходы микропроцессора Broadcom. Используются при работе со специальными пакетами Rpi.GPIO. В большом количестве проектов используется именно эта нумерация.
  • WiringPi – нумеруются контакты для пакета Wiring Pi. Это библиотека, похожая на библиотеки для Ардуино, для работы с GPIO контактами.
  • Обычная цифровая нумерация выходов на самой плате.

Расположение контактов изображено на рисунке. На картинке для удобства последние 14 контактов отделены – это и есть новые выходы, которые были добавлены в новых версиях платы.

Описание контактов GPIO

Номер выводаBCMWiringPiОписание контакта
13v3Питающий контакт на 3,3В
25vПитающий контакт на 5 В
3BCM28SDA
45vПитающий контакт на 5 В
5BCM39SCL
6GNDЗемля
7BCM47GPCLK0
8BCM1415TXD – отвечает за передачу данных
9GNDЗемля
10BCM1516RXD – отвечает за прием данных
11BCM170Вывод общего назначения
12BCM181PCM_C – используется в сочетании с ШИМ-методом.
13BCM272Контакт общего назначения
14GNDЗемля
15BCM223Контакт общего назначения
16BCM234Контакт общего назначения
173V3Питающее напряжение 3,3В
18BCM245Контакт общего назначения
19BCM1012MOSI
20GNDЗемля
21BCM913MISO
22BCM256Контакт общего назначения
23BCM1114SCLK
24BCM810CS0
25GNDЗемля
26BCM711CS1
27BCM030ID_SD
28BCM131ID_SD
29BCM521Контакт общего назначения
30GNDЗемля
31BCM622Контакт общего назначения
32BCM1226Контакт общего назначения
33BCM1323Контакт общего назначения
34GNDЗемля
35BCM1924MISO
36BCM1627Контакт общего назначения
37BCM2625Контакт общего назначения
38BCM2028MOSI
39GNDЗемля
40BCM2129SCLK

 

Выводы земля,  напряжение питания и другие аналогичные можно использовать любые, которые будут удобнее в конкретном проекте. Важно следить за тем, чтобы напряжение на GPIO было 3,3В, иначе контакт может быть вывеен из строя.

Среди выводов общего назначения имеются UART-контакты (на восьмом и десятом контактах). Они позволяют обеспечить взаимодействие Ардуино и Raspberry Pi. Также 4 вывода поддерживают I2C, главной задачей которых является коммуникация с периферией. Для верификации в коде нужно добавить строки

sudo apt-get install i2c-tools

sudo i2cdetect -y 1

Для осуществления доступа к I2C нужно подключить библиотеку smbus.

SPIподдерживают 11 выводов общего назначения. С помощью этого интерфейса можно настроить подключение нескольких устройств с помощью одной группы контактов.

Пример проекта: мигание светодиодов

Для работы понадобятся плата Raspberry Pi, светодиод, резистор на 200 Ом и соединительные провода. Анод светодиода (длинная ножка) нужно подключить через резистор к одному из цифровых выводов, например GPIO24, катод (короткая ножка) – к земле. Макет подключения представлен на рисунке. Резистор в данной схеме нужен для того, чтобы уберечь светодиод от перегорания. Выбрать правильный номинал можно пользуясь законом Ома R=U/I. Плата работает от напряжения 3,3В. Номинал, который будет получен по формуле – минимальный, можно выбирать сопротивление больше, но в этом случае яркость светодиода будет несколько ниже.

Теперь нужно написать программу. Код будет написан в установленной версии Python 2. Для этого нужно открыть среду Python 2 (IDLE) и нажать «новый файл».

В окно редактора нужно написать скетч, который заставит светодиод загореться на 10 секунд и отключит его. В первую очередь нужно выбрать нумерацию выходов. Как говорилось выше, существует несколько типов нумерации. В данном случае будет использоваться нумерация BCM.

Сам код выглядит следующим образом:

[py]

from RPi import GPIO

from time import sleep //первые 2 строки включают библиотеки для совместной работы с GPIO и sleep

GPIO.setmode(GPIO.BCM)  //этой строкой выбирается нумерация контактов

GPIO.setup(24, GPIO.OUT) //чтобы управлять светодиодом или другим устройством, нужно задать OUT. Для того чтобы считывать сигнал сенсора, нужно ввести IN.

GPIO.output(24, True) //подача истины на контакты

sleep(10) //светодиод загорается на 10 секунд, ожидание

GPIO.output(24, False)

GPIO.cleanup() //сброс всех настроек портов, чтобы они не мешали следующей программе.

[/py]

Нужно нажать запуск программы с помощью F5 или меню Run/Run Module.

Код можно немного изменить, чтобы светодиод включался и выключался с определенной частотой. Для этого нужно добавить оператор while вместо строк GPIO.output и Sleep.В цикле нужно задать частоту, с которой будет мигать светодиод. В данном случае он будет мигать раз в 1 секунду.

[py]

while True:

GPIO.output(24, True)

sleep(1)

GPIO.output(24, False)

sleep(1)

[/py]

Большим недостатком такой программы будет то, что она будет повторяться бесконечно и остановить штатным методом ее будет невозможно. Для этого нужно ввести дополнительно конструкцию, прерывающую работу при наборе на клавиатуре комбинации Ctrl+C.

[py]

try:

while True:

GPIO.output(24, True)

sleep(0.5)

GPIO.output(24, False)

sleep(0.5)

except KeyboardInterrupt:

print ‘program stop’

[/py]

Программу нужно сохранить, нажав ctrl+S. Затем нужно нажать F5, светодиод начнет мигать с периодичностью раз в секунду. Чтобы остановить выполнение программы, нужно нажать ctrl+C.

Выводы

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

arduinomaster.ru

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *