8-900-374-94-44
Как-то я писал о том, что планирую использовать Raspberry Pi в качестве веб-сервера, управляющего моим устройством. Пришло время задуматься над интерфейсом подключения. У разработчика, желающего подключить свое железо к Raspberry есть два пути: использовать для этого USB или выводы общего назначения (GPIO). С возможностями USB все приблизительно понятно (в будущем постараюсь написать пост о работе с внешним железом через USB). О GPIO же информации не так много, да и опыта его использования нет. В общем я заинтересовался GPIO и его возможностями. В статье речь пойдет о выводах общего назначения Raspberry Pi — GPIO:
Предварительно я наладил удаленную работу с Raspberry Pi через SSH, чтобы каждый раз не подключать монитор и клавиатуру.
Поэтому в исходном состоянии у меня к Raspberry подключено всего два «провода»: питание и сетевой кабель для соединения с роутером. Хотя принципиального значения это не имеет: все нижеописанное будет справедливо, как в случае работы с консолью Raspberry через SSH, так и при использовании подключенной клавиатуры.
Порт GPIO (сокращение от General Purpose Input Output) — это программно управляемые выводы общего назначения, которые могут работать как входы (для считывания сигнала) или как выходы (для передачи сигнала). На Raspberry Pi они выполнены в виде двух рядов штырьков с шагом в 2,54 мм (разъем PLD). Выражение «общего назначения» означает, что эти выводы пользователь может использовать в своих целях так, как ему захочется, поскольку они не выполняют каких-то определенных жестко заданных функций. При работе с GPIO следует только иметь ввиду, что это цифровые выводы с максимальным уровнем напряжения 3,3 В, соответствующим логической единице.
Поэтому программно выводить на GPIO аналоговый сигнал или подавать на него аналоговый сигнал извне для последующий оцифровки нельзя.
Итак, что представляет собой порт GPIO и каковы его возможности? GPIO объединяет в себе 26 выводов, среди которых присутствуют следующие:
Каждый из этих 17 выводов может работать как вход, либо как выход. Однако помимо этого, некоторые из этих выводов могут выполнять альтернативные
необязательные функции. Что это значит? Каждый из таких выводов в зависимости от программной настройки могут работать либо как обычный вывод, либо как вывод одного из последовательных интерфейсов. С помощью таких выводов GPIO альтернативно могут реализовываться последовательные интерфейсы I2C, SPI и другие последовательные интерфейсы посредством UART.
Примечание: Это знакомые понятия для тех, кто сталкивался с программированием микроконтроллеров. Для тех, кто не сталкивался и на данном этапе пока желает просто программно выводить «1» и «0» на нужном выводе — знания этих интерфейсов не понадобится. Поэтому не буду здесь уделять этому внимание. Скажу только, что среди микроконтроллеров и других устройств (различные датчики, АЦП, ЦАП, микросхемы памяти) это очень распространенные интерфейсы, поэтому наличие выводов этих интерфейсов в GPIO Raspberry при необходимости позволяет очень легко и с минимумом программного кода «научить» Raspberry «общаться» с вашим устройством.
Как понять где какой вывод находится? Для этого необходима распиновка (цоколевка) GPIO. В официальной документации приведена распиновка разных версий GPIO Raspberry Pi. Здесь я приведу самую последнюю на данный момент распиновку GPIO — для Raspberry Pi Model B Rev.2:
На схеме в скобках указана альтернативная функция каждого вывода:
Пожалуй, это самый важный раздел.
Нужно помнить о некоторых особенностях GPIO и соблюдать определенные меры предосторожности, чтобы не залететь еще на 35-50$ не повредить Raspberry. Ниже приведены такие «критические особенности», а также несколько нюансов, которые просто могут быть полезны, и которые желательно помнить при разработке.
Если подать на GPIO вывод Raspberry логическую единицу, представляющую собой 5 В, а не 3,3 В — вывод может выйти из строя.
Пожалуй, все.. Ну и в целом нужно помнить, что GPIO — это выводы, непосредственно подключенные к процессору Raspberry Pi, они являются инструментом для взаимодействия с ним. Поэтому неосторожное обращение с GPIO может привести к необратимым последствиям для процессора. На этом с «пугалками» заканчиваю. Главное и простое правило — не подавать больших напряжений и не потреблять большой ток. Переходим к делу.
Примечание: Работать с GPIO, по сути, можно двумя способами:
1) Используя bash и файловую систему Rasbian
Raspbian является одним из дистрибутивов Linux, а концепция Linux предполагает, что любой объект является файлом.
2) Используя языки программирования (самые разные от C до Бэйсика)
Это более гибкий и более производительный вариант, поскольку он не требует обращения к файловой системе. При этом взаимодействовать с GPIO Raspberry можно на самых разных языках, внушительный список которых приведен здесь вместе с примерами. Ниже разберем пример работы с GPIO на Python.
Предположим нам нужно вывести логическую «1» или «0» на GPIO7 и считать сигнал с 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.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» и обратно, если управлять портом программно. Для проверки этого использовался следующий код:
import RPi.GPIO as GPIO
GPIO.
setmode(GPIO.BCM)
GPIO.setup(7, GPIO.OUT)
while (1):
GPIO.output(7, True)
GPIO.output(7, False)
Как можно применить все это на практике? Зачем выводить «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.
В сегодняшней статье мы рассмотрим основные нюансы и механизмы управления портами ввода-вывода GPIO платы Raspberri Pi.
И, конечно же, как обычно, все проверим на практическом примере.
Все версии Raspberry Pi оснащены штыревым разъемом, на который выведены порты GPIO. Начиная с 2014-го года разъем стал 40-пиновым (ранее было 26). На версиях Pi Zero и Pi Zero W присутствует посадочное место для разъема, но физически он не распаян:
В любом случае, как и с любой другой платой, расположение сигналов на этом разъеме для конкретной модификации лучше всего проверить по официальному даташиту. Хотя на разных версиях плат 40-пиновые разъемы для совместимости идентичны. Распиновка и сам разъем выглядят следующим образом:
Порты можно разделить на несколько категорий:
Разберем по очереди… Пины 3.3V и 5V могут использоваться для питания внешних устройств, подключенных к плате. При этом ограничение по току выглядит так:
I_{5V} = I_{вх} \medspace - \medspace I_{п}где I_{вх} — это входной ток источника, который мы используем для питания платы.
А I_{п} — это ток, потребляемый самой платой, а также внешними устройствами, подключенными по USB. То есть мы подаем входной ток, часть его потребляют узлы платы, а то, что остается мы можем использовать для дополнительных устройств, подключенных к пину 5V.
В итоге за вычетом выводов 3.3V, 5V и Ground остаются 28 пинов GPIO, помеченных на схеме зеленым. GPIO0 и GPIO1 можно считать зарезервированными (их назначение обязательно обсудим в отдельной статье). Таким образом, остается 26 выводов, которые можно использовать по-своему усмотрению. Каждый из них может быть сконфигурирован на работу в том или ином режиме. Вот, к примеру, возможные функции портов для платы Raspberry Pi 4:
То есть любой из портов ввода-вывода может выполнять до 6-ти различных функций, в зависимости от конфигурации. В частности, GPIO2 может быть использован как сигнал SDA для I2C1 (SDA1), либо, к примеру, как сигнал MOSI для интерфейса SPI3 (SPI3_MOSI).
Об I2C и SPI поговорим в ближайших статьях, а сегодня нас интересует использование GPIO в качестве «обычных» входов и выходов. В режиме выхода на пин может быть выведен высокий (3.3 В) или низкий (0 В) уровень напряжения. А, соответственно, в режиме входа мы можем проанализировать, какой уровень подан на пин — высокий или низкий — 3.3 В или 0 В. Тут важно обратить внимание, что порты не являются толерантными к 5 В, то есть подавать на вход 5 В категорически нельзя.
В режиме входа для любого из GPIO можно активировать внутреннюю подтяжку к питанию или земле (pull-up/pull-down). Если вывод настроен на использование подтяжки вверх, то это означает, что при отсутствии сигнала со входа будет считываться высокий уровень. С pull-down ситуация обратная — на входе в данном случае будет низкий уровень.
Исключением являются пины GPIO2 и GPIO3. Они имеют фиксированную подтяжку вверх, без вариантов.
В режиме выхода мы снова возвращаемся к ключевому параметру, а именно к ограничению по току.
Максимальный ток для одного вывода составляет 16 мА. При этом, если используются несколько выходов, то суммарный ток не должен превышать 50 мА. Превышение допустимых значений с большой вероятностью приведет к выгоранию порта.
Собственно, давайте рассмотрим практический пример. Задействуем два вывода GPIO — один в качестве входа, второй в качестве выхода. На вход подключим кнопку, а на выход — светодиод. И реализуем программу, которая будет опрашивать сигнал на входе и по нажатию кнопки зажигать светодиод.
Выберем GPIO3 для светодиода и GPIO4 для кнопки. Схема подключения будет такой:
Давайте в двух словах разберем, что, как и зачем подключено. Начнем с кнопки. Программно активируем для GPIO4 подтяжку вверх, поэтому если кнопка не нажата мы получим на входе высокий уровень (логическую единицу). Соответственно, для того, чтобы определить нажатие кнопки, подключим ее к земле. В итоге при нажатой кнопке на входе будет низкий уровень (логический ноль).
Поскольку используем внутреннюю подтяжку, в этом примере ставить дополнительный внешний резистор подтяжки не будем.
Резистор R_{1} — токоограничительный. Как вытекает из названия он нужен для ограничения тока ) Рассмотрим, что произойдет, если вывод GPIO4 будет ошибочно настроен не как вход, а как выход и на нем будет 3.3 В. При нажатии кнопки произойдет короткое замыкание 3.3 В на землю, что приведет к безвозвратному повреждению порта платы. Это в случае отсутствия резистора.
А при наличии резистора ток будет ограничен величиной:
I = \frac{3.3 \medspace В}{1000 \medspace Ом} = 3.3 \medspace мАВ данном случае получаем 3.3 мА, что вполне допустимо, и позволит сохранить порту жизнь в случае возникновения замыкания.
Итак, переходим к диоду, который подключен через резистор R_{2}. Каждому диоду соответствует своя собственная вольт-амперная характеристика (ВАХ), определяющая возможные значения прямого напряжения и тока. Рассмотрим первый попавшийся под руку светодиод, например такой — ссылка:
Открываем даташит на него и находим зависимость тока от напряжения при прямом включении:
Максимальный ток для GPIO в режиме выхода, как мы уже выяснили, составляет 16 мА.
Чтобы не превысить это значение подадим на светодиод, например, 10 мА. Этому току, исходя из графика, соответствует напряжение 2 В. Теперь по закону Ома нам остается только определить величину резистора. На выходе GPIO у нас 3.3 В, на диоде должно падать 2 В, значит на резисторе остается:
U_{рез} = 3.3 \medspace В \medspace - \medspace 2 \medspace В = 1.3 \medspace ВПри этом ток в цепи должен быть равен 10 мА, тогда сопротивление резистора:
R_{2} = \frac{1.3 \medspace В}{10 \medspace мА} = 130 \medspace ОмЕсли точной величины под рукой нет, можно взять резистор номиналом чуть больше. В общем, суть тут одна — обеспечить режим работы, при котором ток через выход не превышает допустимые 16 мА. Для большинства светодиодов в документации просто приводятся конкретные типовые значения напряжения и тока, например 2.5 В и 15 мА. Расчет будет выглядеть точно так же, как и рассмотренный, просто значения другие.
В общем, с подключением разобрались, время переходить к программной реализации.
Существует огромное многообразие возможных способов для управления GPIO, мы же сегодня остановимся на использовании python.
И для работы с портами ввода-вывода используем библиотеку/модуль RPi.GPIO. В Raspberry Pi OS он включен по умолчанию, но в случае отсутствия команда для установки такая:
sudo apt-get install python-rpi.gpio
Создаем файл gpio_test.py и добавляем в него следующий код:
import RPi.GPIO as GPIO import time GPIO_LED = 3 GPIO_BUTTON = 4 DELAY_TIME = 0.5 GPIO.setmode(GPIO.BCM) GPIO.setup(GPIO_LED, GPIO.OUT) GPIO.output(GPIO_LED, GPIO.LOW) GPIO.setup(GPIO_BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_UP) try: while True: time.sleep(DELAY_TIME) if GPIO.input(GPIO_BUTTON) == 0: GPIO.output(GPIO_LED, GPIO.HIGH) print('led on') else: GPIO.output(GPIO_LED, GPIO.LOW) print('led off') except KeyboardInterrupt: GPIO.cleanup() print('exiting')
Пройдемся подробнее, прямо по всем строкам последовательно. Делаем import модулей для работы с GPIO и для использования временной задержки:
import RPi.GPIO as GPIO import time
Добавим переменные для хранения номеров портов и величины задержки. У нас светодиод на GPIO3, а кнопка на GPIO4. Так и определим:
GPIO_LED = 3 GPIO_BUTTON = 4 DELAY_TIME = 0.
Далее настроим режим нумерации портов, чтобы номера соответствовали названию сигнала (например, GPIO3), а не порядковому номеру на разъеме:
GPIO.setmode(GPIO.BCM)
Настраиваем GPIO3 на работу в режиме выхода и гасим светодиод, подав низкий уровень:
GPIO.setup(GPIO_LED, GPIO.OUT) GPIO.output(GPIO_LED, GPIO.LOW)
GPIO4 — в режиме входа с подтяжкой вверх:
GPIO.setup(GPIO_BUTTON, GPIO.
Далее организуем вечный цикл while True, в котором и будем проверять состояние кнопки и мигать светодиодом. Только обернем его в блок try, чтобы отловить исключение, возникающее, когда пользователь завершает процесс (нажав Ctrl + C). В случае завершения выполнения программы вызываем GPIO.cleanup():
LOW)
GPIO.setup(GPIO_BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_UP)
try:
while True:
time.sleep(DELAY_TIME)
if GPIO.input(GPIO_BUTTON) == 0:
GPIO.output(GPIO_LED, GPIO.HIGH)
print('led on')
else:
GPIO.output(GPIO_LED, GPIO.LOW)
print('led off')
except KeyboardInterrupt:
GPIO.cleanup()
print('exiting')
5
IN, pull_up_down=GPIO.PUD_UP)try:
while True:
time.sleep(DELAY_TIME)
if GPIO.input(GPIO_BUTTON) == 0:
GPIO.output(GPIO_LED, GPIO.HIGH)
print('led on')
else:
GPIO.output(GPIO_LED, GPIO.LOW)
print('led off')
except KeyboardInterrupt:
GPIO.cleanup()
print('exiting')Ну и, конечно, здесь же у нас вся полезная работа. Если кнопка нажата (а в нашей схеме этому соответствует низкий уровень/логический ноль на GPIO4), то зажигаем светодиод и выводим сообщение «led on«.
При отпускании кнопки — обратный процесс. Проверять кнопку будем каждые 0.5 с (DELAY_TIME).
Запускаем программу командой:
python gpio_test.py
И теперь, нажимая кнопку, можем наблюдать включение и выключение светодиода, как мы и планировали 👍
Учебное пособие по GPIO для Raspberry PiВ этом учебном пособии по GPIO для Raspberry Pi мы рассмотрим все основы контактов GPIO, также известных как входные и выходные контакты общего назначения.
Эти контакты предназначены для связи с другими схемами, такими как платы расширения, специальные схемы и многое другое.
С помощью этих булавок можно сделать кое-что интересное. В будущем мы рассмотрим гораздо больше проектов, в которых используются эти булавки.
Об этих булавках нужно знать довольно много, и я настоятельно рекомендую вам следовать этому руководству, чтобы лучше понять их, прежде чем вы начнете играть с ними.
Также не забудьте посмотреть наше видео о Raspberry Pi GPIO в списке оборудования. Он проведет вас через все основы, которые вам нужно знать, чтобы начать.
Предупреждение: Экспериментировать с GPIO рискованно и может привести к поломке вашего Raspberry Pi. Знание ограничений мощности контактов GPIO, а также понимание того, что вы подключаете, является обязательным.
Оборудование, которое я использую в этом руководстве Raspberry Pi GPIO, указано ниже.
Наше видео проведет вас по всем темам, описанным в этом руководстве. Если вы лучше учитесь, слушая и видя, то я настоятельно рекомендую вам посмотреть видео.
Если вам понравилось видео, подпишитесь на нас или следите за нами в социальных сетях, чтобы быть в курсе всех самых крутых проектов Raspberry Pi, руководств и многого другого.
Adblock удаляет видео? Поддержите нас, подписавшись на наш сервис без рекламы.
Теперь давайте приступим к этому учебному пособию по GPIO для Raspberry Pi, мы рассмотрим различные типы доступных выводов, как включить модули, что такое набор для прорыва и, наконец, как собрать и запрограммировать простую схему.
Если вы являетесь владельцем Raspberry Pi B+, 2, Zero или 3, то всего у вас будет 40 контактов. Более ранние модели, такие как Raspberry Pi B, имеют всего 26 контактов.
См. ниже схему выводов Raspberry Pi GPIO. Мы включили все три итерации Pi для схемы выводов.
Если вам нужна PDF-версия схемы выводов, вы можете скачать ее здесь.
Как видите, есть не только стандартные контакты, но и те, которые ссылаются на I2C, SPI и UART.
Поначалу все это может показаться пугающим, но когда вы начнете, все будет довольно просто. Множество аббревиатур и технического жаргона сразу отталкивают людей.
В этом разделе мы кратко коснемся того, как настроить контакты, чтобы вы могли использовать их на Raspberry Pi. Мы еще больше углубимся в программирование и использование выводов в будущих проектах Raspberry Pi.
В этом примере и в будущих проектах мы будем использовать Raspbian. Если он у вас не установлен, вы можете узнать, как установить последнюю версию, следуя моему руководству по установке Raspbian.
Если вы используете последнюю версию Raspbian, вы можете начать программировать и использовать контакты GPIO без необходимости дополнительной настройки.
Тем не менее, я рекомендую вам в любом случае обновить Pi до последних пакетов. Если вы этого не сделали, вы можете сделать это, выполнив следующие команды.
Если у вас не установлен пакет GPIO, просто установите его, выполнив следующую команду.
Настройка выводов I2C на Raspberry Pi очень проста и займет всего пару минут.
Во-первых, перейдите к инструменту Raspi-Config, введя следующую команду.
Здесь перейдите к Параметры интерфейса , а затем к I2c , включите I2c, выбрав Да .
Теперь Pi должен предупредить вас, что I2C будет включен после перезагрузки. Затем он спросит, хотите ли вы, чтобы он загружался по умолчанию. Выберите «Да», если вы планируете использовать I2c при каждой загрузке Raspberry Pi.
Теперь мы хотим убедиться, что необходимые модули успешно включены. Для этого введите следующую команду.
Эта команда вернет все запущенные модули, начиная с i2c. Он должен вернуть что-то вроде этого i2c_BCM2708 .
Настройка Raspberry Pi SPI очень похожа на I2c и очень проста, это займет всего пару минут.
Во-первых, перейдите к инструменту Raspi-Config, введя следующую команду.
После загрузки инструмента конфигурации перейдите к Параметры интерфейса , а затем к СПИ .
Включите SPI, и он сообщит вам, что он будет включен после перезагрузки. После этого он спросит, хотите ли вы, чтобы он загружался по умолчанию. Выберите Да, только если вы планируете использовать его каждый раз при загрузке Pi.
Чтобы убедиться, что SPI успешно запущен и работает, используйте следующую команду.
Эта команда вернет все запущенные модули, начиная с SPI. Он должен вернуть что-то вроде spi_bcm2835 . Убедитесь, что вы перезапустили Pi, прежде чем проверять, загружен ли модуль.
Комплект для коммутации позволяет взять все контакты с помощью ленточного кабеля и подключить их к макетной плате или другому устройству. Этот комплект делает работу намного проще и безопаснее, чем работа внутри и вокруг Raspberry Pi.
Существует несколько различных типов наборов для разветвления, которые вы можете купить для выводов Raspberry Pi GPIO.
Лично я предпочитаю тип T, так как его легко читать и использовать. Если вы ищете комплект для прорыва, обязательно ознакомьтесь со списком оборудования выше.
При подключении ленточного кабеля необходимо убедиться, что он подсоединен и обращен от платы. Вы можете увидеть пример правильной установки ленточного кабеля с разделительной платой типа T прямо ниже.
Программирование с использованием контактов GPIO на Raspberry Pi обычно выполняется с использованием языка программирования Python. Эта конкретная схема и код очень просты в использовании и совсем не займут у вас много времени.
Если программирование кажется вам слишком сложным и вы предпочитаете простое решение, вас может заинтересовать что-то вроде Raspberry Pi Cayenne. Пакет программного обеспечения позволяет добавлять датчики, управлять выводами GPIO и многое другое с помощью очень простого пользовательского интерфейса.
Существует огромная разница между этими двумя разными режимами, и вам решать, какой из них вы хотите использовать для своего проекта. У обоих есть свои плюсы и минусы.
Плата GPIO ( GPIO.Board ) ссылается на физическую нумерацию контактов. Например, верхний левый штифт равен 1, а верхний правый штифт — 2. Он продолжает считать вверх по мере продвижения сверху вниз, пока не закончатся штифты. На нашей диаграмме вы можете видеть эту нумерацию в середине каждой группы.
GPIO BCM ( GPIO.BCM ) — это номер канала B roadcom S oc C . На приведенной выше диаграмме вы можете найти номер после GPIO. Например, на Raspberry Pi 3 контакт ниже 3v3 — это GPIO2, поэтому номер этого контакта равен 2 в режиме BCM.
Недостатком BCM является то, что они менялись между версиями (Raspberry Pi Rev 1 и Raspberry Pi Rev 2) и могут измениться в будущем. Если вы хотите быть в безопасности, я рекомендую придерживаться платы GPIO, но, как я уже говорил ранее, вам решать, как вы хотите ссылаться на контакты.
Если вам нравится программировать и много узнавать о Python, посмотрите мой пример ниже.
Во-первых, давайте настроим нашу маленькую схему. У меня есть полезная простая диаграмма, которой можно следовать ниже. Если у вас есть коммутационный комплект, схема, очевидно, будет немного другой, так как ваши провода будут идти от сапожника.
В качестве альтернативы просто подключите положительный конец светодиода к контакту 7 (GPIO4), а отрицательный конец — к резистору, который подключается к контакту заземления.
Теперь давайте создадим файл Python, чтобы мы могли ввести наш скрипт Python.
Давайте напишем небольшой скрипт. Важно помнить, что Python чувствителен к пробелам.
Например, в цикле для убедитесь, что у вас есть четыре пробела для всего внутри цикла. Чтобы объяснить немного дальше, GPIO.output(7, true) Строка должна содержать четыре пробела перед ней.
Теперь выйдите и сохраните, нажав ctrl+x и затем y .
Если запустить наш небольшой скрипт, схема должна ожить.
Вы можете запустить сценарий Python, выполнив следующую команду. Также важно, чтобы вы запускали его как суперпользователь, используя sudo .
Я надеюсь, что это руководство помогло вам познакомиться с основами выводов GPIO.
Как я упоминал ранее в этом руководстве, в будущем я буду выполнять множество проектов, в которых будут использоваться выводы Raspberry Pi GPIO. Этот диапазон проектов включает в себя использование датчиков движения, датчиков температуры, управление двигателями и многое другое.
Если у вас есть какие-либо вопросы, отзывы или если я что-то пропустил, не стесняйтесь оставить нам комментарий ниже.
Похоже, вы неправильно набрали URL-адрес в адресной строке или перешли по старой закладке.
В наличии SEN-09088
7
Избранное Любимый 69
Список желаний
В наличии COM-11705
Избранное Любимый 30
Список желаний
31 в наличии DEV-16829
21,50 $
1
Избранное Любимый 9
Список желаний
В наличии COM-21311
Избранное Любимый 1
Список желаний
25 ноября 2021 г.
Мы так любим День Турции!
Избранное Любимый 0
8 июля 2022 г.
На этой неделе у нас есть два новых комплекта GPS-RTK с ZED-F9P и ZED-F9R, а также два новых продукта с двумя антеннами ESP32 WROOM!
Избранное Любимый 0
Это руководство поможет вам приступить к работе с электролюминесцентным (EL) проводом, лентой, панелью, проволокой для чеканки и гибким проводом, чтобы ваш проект засиял!
Избранное Любимый 14
Важные детали для начинающих (и даже опытных) любителей, которые содержат все основные сквозные компоненты, необходимые для начала работы со встроенными проектами.