Разъем gpio что это и как использовать
Изучаем STM32. Урок 2. Изучаем порты ввода-вывода GPIO (ч1)
Добрый день, итак, пока есть время между редактированиями кодов и пайками)) напишу ещё одну статейку. На этот раз мы будем знакомиться с нашими ножками (нет не теми что внизу), а теми которые находятся на микроконтроллере и за счёт чего он воспринимает сигналы из внешнего мира и соответственно передаёт сигналы в него.
Итак, давайте посмотрим на блок — схему порта ввода-вывода контроллера
Тут у нас справа расположены защитные диоды, дальше внизу расположен регистр вывода и на нём мы видим два полевичка один из которых N-канаьный, второй P-канальный. Именно они нам выдают либо лог. единицу, либо лог. ноль.
Вверху нарисован регистр ввода, в котором мы видим триггер шмидта, перед ним мы видим резисторы подтяжки
Ну кому более интересно это, тот может найти feference manual и выучить всё от корки до корки, мы же в данной части урока просто разберёмся что значат разные режимы работы наших портов
Итак, помните в прошлом уроке мы настраивали чем у нас будет ножка контроллера — Входом, Выходом. Но это не все параметры. Ещё ножка может быть сконфигурирована как аналоговый вход\выход для допустим работы с АЦП, или с ЦАП, у кого он есть на «борту»))
Давайте рассмотрим все режимы работы
1)Input floating — по простому это вход безо всяких подтяжек (Hi-Z состояние, плавающий). По простому вход у нас ни к чему не подключён (привет помехи))))
2)Input pull-up — режим входа, в котором он чрез подтягивающий резистор подключён к питанию (номинал резистора несколько десятков килоОм)
3)Input-pull-down — режим входа, в котором он чрез подтягивающий резистор подключён к земле (массе) (номинал резистора несколько десятков килоОм)
4)Analog — режим работы, который включаем если желаем работать с АЦП или ЦАП
5)Output open-drain with pull-up or pull-down capability — выход с «открытым коллектором»
6)Output push-pull with pull-up or pull-down capability — самый используемый режим, в котором наш пин может выдавать как лог. ноль так и лог. единицу (это будут работать те самые полевые тарнзисторы о которых писал выше)
7)Alternate function push-pull with pull-up or pull-down capability — альтернативная функция (двухтактный вывод)
8)Alternate function open-drain with pull-up or pull-down capability — альтернативная функция (открытый
коллектор)
Теперь опишу как работаем с этими параметрами в нашей среде программирования.
Вот смотрите, кусочек кода, который отвечает за настройку параметров выхода
GPIO_InitStruct.Pin = GPIO_PIN_0; — данная строчка кода указывает что конфигурировать мы будем ножку 0
GPIO_InitStruct.Mode = GPIO_MODE_INPUT; — Данная строчка указывает что режим работы — Вход
У данной строчки могут быть вот такие параметры
GPIO_MODE_INPUT
GPIO_MODE_OUTPUT_PP
GPIO_MODE_OUTPUT_OD
GPIO_MODE_AF_PP
GPIO_MODE_AF_OD
Следующая строчка GPIO_InitStruct.Pull = GPIO_PULLDOWN; — Указывает что у нас подтяжка к массе. У данной строчки ещё могут быть вот такие варианты
GPIO_NOPULL
GPIO_PULLUP
GPIO_PULLDOWN
Ну и последняя строчка указывает нам с каким портом нашего контроллера мы вообще только что разговаривали) — HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
Здесь мы рассмотрели настройку нашего пина к которому подключена кнопка. PA0.
Также, чтобы работал наш порт, и мы что то могли с ним делать — нам нужно включить тактирование порта. Так как мы создаём проект в CubeMX, то он за нас это всё делает, но на будущее, мало ли, может кто то захочет использовать старые библиотеки- не забывайте подавать тактирование на нужные вам порты.
В нашем случае тактирование наших портов включается вот таким образом
/* GPIO Ports Clock Enable */
__GPIOA_CLK_ENABLE();
__GPIOD_CLK_ENABLE();
Если поищем дальше, что обозначают эти строки то вот что найдём. Функция включения тактирования нашего порта A.
#define __HAL_RCC_GPIOA_CLK_ENABLE() do < \
__IO uint32_t tmpreg; \
SET_BIT(RCC->AHB1ENR, RCC_AHB1ENR_GPIOAEN);\
/* Delay after an RCC peripheral clock enabling */ \
tmpreg = READ_BIT(RCC->AHB1ENR, RCC_AHB1ENR_GPIOAEN);\
UNUSED(tmpreg); \
> while(0)
Ну а теперь код, с помощью которого мы управляем нашими пинами.
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_RESET); — сбрасывает пин в НОЛЬ
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, GPIO_PIN_SET); — устанавливает пин в ЕДИНИЦУ
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_9); — изменяет состояние пина на противоположное. Если было 0, то станет единица, и наоборот.
Ну и добавлю сюда ещё одну функцию — функция задержки Delay. Мы её часто использовали в CAVR, и тут она тоже есть. Задаётся она в милисекундах и выглядит вот так — HAL_Delay(100);
Это означает задержка в 100 милисекунд.
Можете теперь поиграться светодиодами на плате, выставив задержку и используя HAL_GPIO_TogglePin. Ваши светодиоды будут по очереди перемигиваться.
Жмём палец вверх, и читаем, читаем, читаем мануалы, и уже в голове придумываем что мы сделаем на STM32! STM — мечты сбываются)))
Ну и не забываем про хорошую музычку, да погромче! Пока писал — наслаждался вот этим шедевральным концертом. С ним как то и светодиоды по другому перемигиваются))
Первое знакомство с GPIO в Raspberry PI
Самое интересное в разработке на Одноплатных компьютерах — это общение с внешним миром. Вот что позволяет «Малина» — это подключение датчиков, концевиков, двигателей, лампочек, различных исполнительных органов. В Raspberry Pi GPIO является самой привлекательной частью. Я считаю, что для роботов это просто идеальные «мозги».
Из этой статьи вы узнаете:
Приветствую вас, друзья!! Сегодняшняя тема статьи будет посвящена физическим входам и выходам на одноплатном компьютере Raspberry. Именно этим «Малина» и заслужила такую недетскую популярность. Очень много различных модулей сделано для Raspberry, и разрабатываются всё новые и новые.
Что можно подключить? Да все те же датчики и дополнительные платы, что и на Arduino. На борту есть два интерфейса, таких как SPI и I2C, по которым можно управлять электроникой. Можно сравнить с протоколом Modbus в системе ПЛК — модули ввода/вывода.
Недавно я научился управлять входами и выходами с помощью скриптов на Python. Показать как?
Знакомство с GPIO
Про старые модели, я так думаю, нет смысла писать. Начнём сразу с 3-ей модели. Давайте разбираться, что такое вообще GPIO.
Аббревиатура GPIO с английского расшифровывается как: General-purpose Input/Output — это интерфейс. который содержит Входы и Выходы общего назначения, к которым можно подключать разнообразные исполнительные устройства, датчики, дисплеи, контроллеры, разные модули и разную периферию.
Интерфейс GPIO выглядит как разъём со штырьками. в третьей «Малине» будет выглядеть следующим образом:
Где какой пин? А вот где они:
На картинке нарисована модель Raspberry Pi 2 model B, не пугайтесь, распиновка одна и та же.
Обратите внимание, что все пины могут быть как ВХОДАМИ, так и ВЫХОДАМИ. Присвоение функции пина происходит программно.
Распиновка Raspberry pi 3:
Особенности работы с GPIO
Перед сборкой и подключением внешних цепей к Raspberry, вы должны знать о таких нюансах:
Вы должны понимать, что GPIO подключены напрямую к процессору, и неграмотное подключение может повредить сам процессор. Будьте внимательны.
Поэтому при проектировании устройств в которых используется большое количество пинов GPIO нужно обязательно делать развязку через дополнительные буфферные схемы, преобразователи уровня напряжений, электронные ключи.
Есть ещё несколько нюансов. После того как Raspberry Pi включена и операционная система Linux загружена, на выводах GPIO установлен низкий уровень (0В), и так до тех пор пока какая-то программа или скрипт не изменит состояние портов.
И все бы хорошо если бы не небольшое НО. Суть его заключается в том, что начиная с момента подачи питания на платформу и до момента инициализации драйверов в ОС, на произвольных пинах могут кратковременно присутствовать высокие уровни (3,3В).
И поэтому неплохим решением, будет изолировать входы и выходы по питанию, при загрузке операционной системы.
Схема подключения светодиода и кнопки
При подключении светодиода не забудьте подключить гасящий резистор (200-300 Ом). Это обеспечит малое потребления тока, как раз меньше 50 мА. Таким образом вы спасёте сам процессор и буфер GPIO.
При подключении кнопки, тоже есть свои нюансы. Очень рекомендуется ставить токоограничивающие резисторы. Кто-то спросит, а почему нельзя поставить просто кнопку, и всё? Я тоже задавался таким вопросом. Оказывается всё просто.
Не забывайте, что при загрузке ОС или неверно установленном режиме GPIO на используемый пин может пойти 3,3 В. Таким образом при замыкании на землю, мы обеспечим короткое замыкание, и таким образом спалим пин, или процессор.
Такая схема с ограничительными резисторами — это гарантия сохранения работоспособности «Малины» в различных ситуациях.
Что даёт такая схема подключения кнопки:
Схема подключения светодиода и кнопки:
R1 — 10 кОм, R2 — 1 кОм, R3 — 220 кОм.
Не жалейте резисторов для данной схемы, лучше всего подвесить на каждый пин по 1 кОм. И настроить схему для уверенной работы. Не экспериментируйте друзья, согласитесь, спалить 3000 р. просто так будет жалко.
Программируем GPIO
Работать с GPIO можно двумя способами:
Управление GPIO из оболочки bash
ОС Raspbian является дистрибутивом Linux, а концепция Linux представляет собой работу с текстовыми файлами, и конфигурирование этих файлов. Пользуемся оболочкой bash в любимом терминале.
Работа через GPIO в Raspberry Pi 3
Одна из основных функций одноплатных компьютеров семейства Raspberry Pi — обеспечивать взаимодействие с разнообразной периферией. Это могут быть датчики, реле и двигатели, лампочки и прочие исполнительные модули и блоки. За такое «общение» отвечает встроенный в платы Raspberry Pi GPIO — интерфейс ввода-вывода. Рассмотрим его подробнее на примере RPi 3 B.
Что такое колодка GPIO
GPIO — сокращение, означающая General-Purpose Input-Output, или общий интерфейс ввода/вывода. Он содержит цифровые входы и выходы для подключения датчиков, разнообразных контроллеров, дисплеев, реле и прочей электронной периферии. Внешне GPIO похож на «гребенку» из штырьков-пинов. В Raspberry Pi 3 его внешний вид таков (в верхней части платы):
Колодка GPIO Raspberry чем-то напоминает интерфейс подключения жестких дисков IDE.
Для правильной работы через GPIO необходимо знать конфигурацию пинов. В Raspberry Pi распиновка такова:
Разъемов питания 4. Прочие пины способны выступать в роли входа или выхода. Кроме того, некоторые из них многофункциональны и могут работать как интерфейс UART, I2C, SPI или ШИМ.
Рассмотрим более подробно устройство «гребенки».
Устройство GPIO
Число пинов на колодке GPIO Raspberry Pi 3 равняется 40. Они пронумерованы и делятся на три группы:
Первые необходимы для подачи электричества разных напряжений — 3.3 и 5 В. Разница между ними была рассмотрена выше. Вторые обеспечивают безопасность работы платы, отводя электричество. А третьи выступают в качестве интерфейсов, принимая и отдавая данные. Именно к ним пользователь подключает свои модули и приборы.
Схема пинов Raspberry Pi 3 Model B:
На данной схеме pinout выводы пронумерованы по следующему принципу:
Выходы 1 и 17 обеспечивают питание 3.3 В, 2 и 4 — для 5 В. «Земля» расположена на 9, 25 и 39, и на 6, 14, 20, 30, 34. Прочие контакты — интерфейсные порты.
Особенности GPIO «малинки»
При работе необходимо учитывать несколько важных моментов:
Важно помнить: все «ножки» колодки соединены с процессором напрямую, некорректные операции и неверное подключение способно привести к полной неработоспособности платы.
Поэтому при правильном проектировании приспособлений с большим количеством используемых выводов GPIO схема должна предусматривать дополнительные меры безопасности. Желательно делать защитные развязки электронными ключами, через трансформаторы напряжений и различные буферы.
Как правило, RPi3 работает под управлением ОС семейства Linux (Raspbian или другой). Сразу после загрузки системы напряжение на пинах низкое и остается таковым до изменения запустившимся скриптом или программой. Но в промежуток от подачи электропитания до инициализации системных драйверов пины в произвольном порядке способны выдавать высокое напряжение. Это следует учитывать и изолировать по питанию входы-выходы в процессе запуска системы.
Особые порты
Внешние модули можно подсоединять к любым портам «гребенки» GPIO. Но есть два особенных, которые плата резервирует для специфических задач. На обычной схеме их номера — 27 и 28. Они предназначены для плат расширения, и желательно не использовать их без необходимости.
Нумерация
Выше рассматривались номера пинов. Но важно понимать, что заложенная в центральный процессор логическая нумерация отличается от приведенной на схеме физической. Ее особенности:
Этот принцип следует учитывать при создании кода, поскольку ПО ориентируется именно на логические номера. Их схема:
У новичков это может вызвать недоумение и путаницу. Для помощи в решении проблемы существует программная библиотека Wiring Pi с собственной альтернативной нумерацией. Так, логический GPIO2 в ней определен как WIringPI 8. Это может показаться непонятным, но после освоения библиотеки ее принцип нумерования становится привычным и удобным.
Способы взаимодействия с интерфейсом GPIO
Интерфейсная гребенка позволяет работать с собой несколькими путями:
Управление на bash
Чтение данных со входа номер 24:
echo 24 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio24/direction
cat > /sys/class/gpio/gpio24/value
Управление через Python
Питон — один из самых популярных языков разработки под Raspberry, и в нем создан богатый инструментарий. В последних дистрибутивах ОС Raspbian уже присутствует и сама среда Python, и необходимая для работы библиотека RPi.GPIO. Если же таковой нет, ее можно загрузить из репозитория:
sudo apt-get install python-rpi.gpio
Далее необходимо подгрузить этот модуль в программу:
import RPi.GPIO as GPIO
Далее следует определиться с порядком нумерации — брать ли «физический» по номерам портов на микрокомпьютере, или использовать принцип обращения по номерам процессорных каналов (BCM):
GPIO.setmode (GPIO.BOARD)
GPIO.setmode (GPIO.BCM)
Преимущество первого пути — универсальность: он будет работать с любой ревизией контроллера. BCM обращается непосредственно к каналам процессора на более низком уровне.
На следующем шаге выбирается режим работы портов input или output.
GPIO.setup(channel, GPIO.IN)
GPIO.setup(channel, GPIO.OUT)
Сразу же можно определить начальное состояние выходов RPi3:
GPIO.setup(channel, GPIO.OUT, GPIO.LOW)
GPIO.setup(channel, GPIO.OUT, GPIO.HIGH)
Команда на чтение информации со входа:
Запись значения на выход GPIO:
Пример работы
Рассмотрим пример взаимодействия RPi3 и простой схемы со светодиодом через написанную на Python программу.
Для начала понадобится «малинка» с установленным ПО и средой разработки, макетная плата, диод, кнопка и резисторы. Схема подключения приведена ниже:
Здесь R1 имеет сопротивление 10 кОм, R2 — 1 кОм, а резистор R3 — 220 кОм.
Что обеспечивает подобная модель:
Написанный на Python скрипт включения-выключения лампочки:
Import RPi.GPIO as GPIO
GPIO.setmode (GPIO.BCM)
GPIO.setup (4, GPIO.OUT)
GPIO.output (4, 1)
GPIO.cleanup ()
Для «моргания» диодом:
import RPi.GPIO as GPIO #импорт библиотеки дл¤ работы с GPIO
import time #импорт библиотеки дл¤ ожидани¤
GPIO.setmode(GPIO.BCM) #»запуск» GPIO
GPIO.setup(4, GPIO.OUT) #объ¤вл¤ем 4 порт как выход
while True: #цикл
GPIO.output(4, 1) #вкл светодиода
time.sleep(1) #пауза 1 с
GPIO.output(4, 0) #выкл светодиода
time.sleep(1) #пауза 1 с
Включение лампочки с кнопки:
import RPi.GPIO as GPIO #импорт библиотеки дл¤ работы с GPIO
GPIO.setmode(GPIO.BCM) #»запуск» GPIO
GPIO.setup(4, GPIO.OUT) #объ¤вл¤ем 4 порт как выход
GPIO.setup(3, GPIO.IN) #объ¤вл¤ем 3 порт как вход
while True: #цикл
if GPIO.input(3) == False: #если кнопка нажата
GPIO.output(4, 1) #вкл светодиода
else:
GPIO.output(4, 0) #выкл светодиода
Пример управления выходами с клавиатуры:
Готовую программу следует сохранить в удобную папку и запустить командой Питона:
sudo python путь_к_исполняемому_файлу/имя_программы.py
Python предоставляет широкое поле возможностей для программирования «Распберри» и позволяет реализовывать гораздо более сложные схемы. Кроме того, с платой можно взаимодействовать на практически любом распространенном языке — одном из семейства C, Perl, Erlang и другое. Существуют даже реализации проектов на Java и HTML5.
Заключение
GPIO — удобное и универсальное решение, позволяющий подключать к RPi 3 разнообразную периферию и программировать ее поведение на одном из привычных языков. Логика взаимодействия довольно проста, а GPIO, как и сама «малинка», хорошо документирован, что обеспечивает легкий вход в программирование с использованием этого интерфейса даже новичкам в мире IT.
Начинающим можно порекомендовать язык Python, как несложный в освоении и логичный. В нем присутствуют все необходимые библиотеки работы с GPIO, ускоряющие и упрощающие процесс разработки.
Где купить
Видео по теме
GPIO для чайников (часть 1)
Что делать, когда нечего делать? Попробовать что-нибудь новое!
Но всё ж таки Raspberry Pi может делать одну вещь гораздо более эффективнее, чем любой домашний компьютер- он может управлять внешними устройствами. Устройства могут быть абсолютно любыми, от обычной лампочки, до беспилотного летательного аппарата. В данном случае, область применения Raspberry ограничена лишь вашей фантазией и знаниями. И если вы никогда и ничего подобного не делали, но это вас заинтересовало, то эта статья для вас. И так, начнём.
Во-первых, нужно найти светодиод:
Его можно достать из старой сломанной игрушки, из зажигалки с фонариком, попросить у знакомого радиоэлектронщика, в конце концов, просто купить.
Во-вторых, понадобятся проводочки любые и парочка коннекторов BLS:
Такие коннекторы можно вытащить из старого системного блока вместе с проводами, или попросить у знакомого компьютерщика, или тоже купить. Они прекрасно подходят для подключения к разъёму на Raspberry.
Вот собственно как эти порты расположены на плате:
Чтобы светодиод зажёгся, нам нужно его подключить к источнику питания. Выбираем для питания светодиода Р1-01, верхний по рисунку штырёк, на котором присутствуетнапряжение 3,3в. Для управления светодиодом нам понадобится один порт GPIO. Можно выбрать любой. Но если у вас есть разъём BLS, то удобнее в данном случае использовать порт, который выведен на штырёк P1-03 и называется GPIO 0. В таком случае мы, воспользовавшись одним разъёмом, сможем подключить наш светодиод. И так, мы будем подключать светодиод между ножками разъёма P1-01 и Р1-03. С вывода Р1-01 мы берём +3,3в для питания светодиода, а вывод Р1-03 будет тем самым управляющим выводом порта GPIO. Все эти порты физически находятся внутри центрального процессора Raspberry Pi, который называется BCM2835. Этот процессор может подключать любой порт к источнику напряжения 3,3в, а может подключить порт к 0 питания (а может вообще никуда не подключать, но об этом позже). Эти переключения он делает в соответствии с поданной командой. Значит, когда порт будет подключён к напряжению +3,3в, наш светодиод гореть не будет, т.к. току некуда идти. А когда процессор подключит порт к 0, то наш светодиод загорится, т.к. ток побежит от +3,3в к 0 через светодиод. Значит наша программа должна будет отдавать соответствующие команды процессору в соответствии с нашим желанием.
Маленькое, но важное. На самом деле, мы не должны подключать светодиод напрямую между источником питания +3,3в и выводом порта. Это нельзя делать по двум причинам. Причина первая: любой светодиод нормально работает при определённом токе. Если через светодиод потечёт большой ток (а выход +3,3в способен отдать до 50мА), то светодиод сгорит. Если маленький ток, то светодиод будет гореть слишком слабо, либо вообще не будет светиться. Для большинства обычных светодиодов рабочий ток находится в пределах 10-20мА. Отсюда вытекает и вторая причина (хотя в данном случае она несущественна). Если мы пропустим большой ток через порт GPIO, то этим самым мы уничтожим процессор и Raspberry- умрёт. Поэтому, мы должны следить, чтобы через порт не протекал ток больше допустимого. Примем для себя ограничение в 16мА, так мы точно не сожжем процессор. Как этого добиться? Очень просто! Нам нужно последовательно со светодиодомвключить токоограничивающий резистор. И сейчас мы его рассчитаем.
Примем для светодиода рабочий ток в 10мА. Убеждаемся в том, что выбранный нами ток не превышает предельно допустимый ток для порта в 16мА. Теперь зная напряжение питания 3,3в и рабочий ток 10мА, мы можем по закону Ома рассчитать необходимое нам сопротивление. R=U/I=3,3/0,01=330Ом. Значит нам нужно найти резистор с сопротивлением 330Ом. А точнее- сопротивлением не менее 330Ом. Больше- можно. Светодиод будет заметно светиться и при сопротивлении 1000 Ом, или 1кОм. В общем наша задача- найти резистор с сопротивлением от 330 Ом до 1кОм. Если вы его нашли, то можно собрать вот такую схему:
Схему лучше собрать на макетной плате. Лично мне, для экспериментов, мой сын дал на прокат свой конструктор «Знаток».
Так выглядит схема в сборе:
Так мы подключаемся к Raspberry:
А вот общий план всей конструкции:
Почему на именно на Си? Просто по тому, что я других языков не знаю, а раз вы читаете эту статью, то скорее всего вы тоже немного знаете о программировании и радиоэлектронике, а значит, вам всё равно с какого языка начинать.
Обычно изучение языков программирования начинают с написания программы «Hello World!», но мы же круче «тех» чайников, поэтому мы начнём сразу с низкоуровневой работы с периферией. Тем более, что это не намного сложнее ХеллоуВорлда. 😉 Что для этого нужно? Нужен любой текстовый редактор, в котором мы будем набирать программу. В Raspbian есть отлично подходящий для этого редактор “nano”. Ещё нужен компилятор, это программа, которая осуществляет перевод написанной нами программы с человечески понятного языка на язык, понятный компьютеру. Т.е. делает из нашей программы исполняемый файл, который мы впоследствии и запустим на Raspberry. Эта штука тоже у нас есть, называется gcc. Этот компилятор поставляется в комплекте со всеми Линуксами и уже готов к работе.
Как видите,всё необходимое у нас уже есть. Хотя нет. Одной вещи все-таки у нас не хватает. Её мы возьмем из интернета. Речь идёт о библиотеке функций управления портами GPIO на Raspberry, специально написанно добрым человеком для того, чтобы наша программа по своей простоте могла бы соперничать с «Хеллоуворлдом» и нам самим бы не пришлось ломать голову, изучая техническую документацию на процессор и протоколы работы с его внутренностями. Сама библиотека состоит из заголовочного файла, в котором обозначены все имена функций со структурами переменных и файла библиотеки самих функций. Эту библиотеку нужно скачать и установить, чтобы компилятор мог с ней работать. Библиотека называется bcm2835-1.17. Последние цифры в названии библиотеки, обозначают её версию. А так, как библиотека постоянно обновляется автором, то версии будут меняться. на сегодняшний день доступна версия 1.17. Узнать о номере последней версии можно по адресу: http://www.open.com.au/mikem/bcm2835/index.html По этой же ссылке вы можете ознакомиться со всеми функциями, которые присутствуют в этой библиотеке.
Мы же пока установим версию 1.17. Запускаем окно терминала и вводим туда команду: wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.17.tar.gz
Библиотека быстренько скачивается. Чтобы её установить, нужно сначала её разархивировать. Это делается следующей командой: tar zxvf bcm2835-1.17.tar.gz
Теперь перейдём в директорию, куда эта библиотека развернулась: cd bcm2835-1.17
Ну и инсталлируем её:
Тут можно создать папочку для наших экспериментов с любым именем, например myprog: mkdir myprog
Перейдём в эту папку: cd myprog
И начинаем писать нашу программу: nanoGPIO-test.c
Эта команда запускает текстовый редактор nano, который создаёт текстовый файл GPIO-test.c.Теперь можете набрать в нём следующую программу (можно просто скопировать и вставить):
Обратите внимание на строки #define. Их в программе 2 и одна из них закомментирована. Одна строка для ревизии RPi v1, вторая для RPi v2. Если у вас v1, то всё оставьте как есть. Если у вас RPi v2, то первую строку с #define удалите, а со второй уберите символ комментария //.В будущем, во всех остальных программах, просто добавляйте _V2_ между RPI и GPIO в определении портов, если ваша плата RPi v2.
Теперь о том, что делает каждая строка в нашей программе.
Все надписи после двойного слеша // являются коментариями и никак не влияют на выполнение программы.
int main() это начало нашей программы, обозначение главной функции в Си.
return 1; то аварийно завершает программу и передаёт на выходе код 1.
Т.е. алгоритм работы с портом GPIO в режиме записи, т.е. вывода, выглядит следующим образом:
1. Инициализируем GPIO;
2. Устанавливаем режим для выбранного порта на Вывод;
3. Теперь можем управлять этим портом, устанавливая его в высокое, или низкое состояние. Соответственно на этом порте будет пристутствовать либо +3,3В, либо 0В. Что соответствует логической 1 и логическому 0 соответственно.
На этом на сегодня закончим. В следующей части научим наш светодиод загораться более полезным образом, а так же научимся портами GPIO не только отдавать команды другим устройством, но и слушать их.А пока можете начинать изучать язык Си. А так же попробуйте изменить эту программу так, чтобы светдиод управлялся бы другим портом и испытайте её.