Категории публикаций
Подписка на рассылку по Email
новости (подписчиков: 3)
комментарии (подписчиков: 2)

Отменить подписку
Популярные публикации
Интересный опрос
Что вас больше всего интересует?

Заработок в интернете
Радиоэлектроника
Программирование
Операционные системы
Информационная безопасность
Саморазвитие, лайфхак
Спорт
Другое
Поблагодарить автора
donate
1B4ZZ2PXUd9E7AqEB82AqFnkpk2bt5hQG7

Изучаем GPIO в Raspberry Pi, эксперимент со светодиодом и кнопкой

Размещено в категории: Железо

Познакомимся с портами общего назначения GPIO (General-purpose input/output) в Raspberry Pi, разберем простой пример с подключением светодиода и кнопки (переключателя) к портам GPIO, а также напишем простую программу на Python, которая будет управлять свечением (миганием) светодиода при помощи кнопки. Простые эксперименты с Raspberry Pi GPIO для начинающих.

Содержание:

  1. Что такое GPIO
  2. GPIO в Raspberry Pi для моделей A и B
  3. GPIO в Raspberry Pi для моделей A+, B+ и B2
  4. Распиновка разъемов GPIO
  5. Использование пинов и меры безопасности
  6. Уровни на пинах GPIO по умолчанию
  7. Светодиод и кнопка - правильное и неправильное подключение
  8. Расчет гасящего резистора для светодиода
  9. Схема эксперимента со светодиодом и кнопкой
  10. Программа для эксперимента со светодиодом и кнопкой
  11. Как управлять пинами GPIO на любом языке программирования
  12. Модуль RPIO
  13. Заключение

 

Что такое GPIO

Первым делом давайте разберемся что такое GPIO и для чего оно нужно. Аббревиатура GPIO с английского расшифровывается как: General-purpose Input/Output - это интерфейс. который содержит Входы и Выходы общего назначения, к которым можно подключать разнообразные исполнительные устройства, датчики, дисплеи, контроллеры, разные модули и разную периферию.

Как выглядит интерфейс GPIO? - это разъем, который размещен непосредственно на платке Raspberry Pi и который содержит набор из пинов:

  • В старых моделях (A и B) - 26 шт (+8шт отдельным разъемом);
  • В новых моделях (A+, B+ и B2) - 40 шт.

Внешний вид разъемов GPIO для разных моделей малинки изображен ниже.

 

GPIO в Raspberry Pi для моделей A и B

Raspberry Pi model B GPIO разъем и нумерация пинов

Рис .1. Raspberry Pi model B GPIO разъем и нумерация пинов.

В версиях A и B разъем содержит 26 пинов (P1 header), 8 из которых являются общими портами ввода-вывода GPIO, а также пины для подключения интерфейсов I²C, SPI, UART и линии питания +5В, +3,3В, GND.

Также в самых ранних версиях можно встретить разъемчик на катором 8 пинов (P2 header) - это интерфейс отладки VideoCore JTAG, в последующих версиях он был исключен. Еще можно заметить несколько нераспаянных разъемов - это: P3 (LAN9512 JTAG), P5 (8 выводов - 4 GPIO, 5V, 3,3V, 2 GND), P6 (для сброса BCM2835, Reset).

 

GPIO в Raspberry Pi для моделей A+, B+ и B2

Интерфейс GPIO в Raspberry Pi 2 и нумерация пинов

Рис. 2. Интерфейс GPIO в Raspberry Pi 2 и нумерация пинов.

В новых версиях платформы Pi разъем уже содержит 40 пинов (2 ряда по 20 штук), первые 26 пинов (по 13 в ряду) такие же как и в более ранних версиях Raspberry Pi, а остальные 14 штук это дополнительные GPIO (9шт), GND(3шт) и 2 вывода для EEPROM.

Больше пинов - больше возможностей по расширению и применению малинки!

 

Распиновка разъемов GPIO

Для того чтобы использовать разъем GPIO необходимо точно знать какой пин и для каких целей можно использовать. Ниже приведены распиновки разъемов GPIO для разных моделей и разных версий платформы Raspberry Pi.

Raspberry Pi model A B - расположение пинов на разъеме GPIO

Рис. 3. Raspberry Pi model A B - расположение пинов на разъеме GPIO.

Важно заметить что у ревизий печатной платы 1.0 (сентябрь 2012 или раньше) и 2.0 расположение пинов немножко отличается:

  • Пин 3 = GPIO0, SDA0, I2C (v1.0)  |  GPIO2 (v2.0);
  • Пин 5 = GPIO1, SCL0, I2C (v1.0)  |  GPIO3 (v2.0);
  • Пин 13 = GPIO21 (v1.0)  |  GPIO27 (v2.0).

Это нужно учесть при проектировании и переделке устройств на платформах с разной ревизией печатных плат.

Распиновка разъема GPIO в Raspberry Pi 2

Рис. 4. Распиновка разъема GPIO в Raspberry Pi A+, B+, 2.

 

Использование пинов и меры безопасности

Прежде чем что-то подключать к пинам интерфейса GPIO давайте разберемся какие напряжения можно подключать и какие мы получим на выходе, нужно помнить что:

  • На выходе пинов мы получим 3,3В (не 5В, как многие могут подумать);
  • Буферы и ключи, которые подключены к пинам НЕ защищены от перегрузки по напряжению;
  • Пины GPIO можно нагружать током 2мА - 16мА;
  • Пины с выходным напряжением 3,3В можно нагружать током не более 50мА;
  • Пины с выходным напряжением 5В стараемся грузить не более чем на 500мА(для Model A) и не более чем на 300мА (для Model B) - почему так, расскажу ниже.

При проектировании устройств в которых используется большое количество пинов GPIO нужно обязательно делать развязку через дополнительные буфферные схемы, преобразователи уровня напряжений, электронные ключи. Для чего это нужно? - чтобы обезопасить себя малинку от возможного повреждения (выгорания) буфферов внутри чипа.

А теперь давайте посмотрим что получится если мы подключим к трем портам GPIO и общему для них выводу 3,3В три светодиода, через каждый из которых будет протекать ток 20мА(сверхьяркие светодиоды): 20мА * 3 = 60мА - что является ПРЕВЫШЕНИЕМ максимально допустимого тока на пине 3,3В и небольшой перегрузкой для пинов GPIO (по 20мА на пин). В данном случае для питания таких светодиодов нам нужно подключить к выводам GPIO дополнительные ключи на транзисторах или микросхемах, которые будут управлять светодиодами и не будут перегружать пины интерфейса.

Если на каждый из нескольких пинов GPIO мы повесим по светодиоду то можно их общую точку подключить к земле, в таком случае светодиод будет светиться если на пине будет присутствовать высокий (+3,3В) уровень, а для ограничения тока до 15мА последовательно светодиоду подключим токоограничительный резистор.

Пины с напряжением 5В подключены к основной шине питания 5В платы (после стабилизатора), большая нагрузка может повлиять на стабильность работы платформы вцелом, а также вывести из строя внутренний стабилизатор напряжения +5В. Нужно с осторожностью отнестись к их использованию, допустимый ток не должен превышать 1А (без учета потребления самой платы): 1А - 700мА(ток потребляемый платой модели B) = 300мА.

В действительности потребляемый малинкой ток во многом зависит от загруженности микропроцессора и видеопроцессора (графическая оболочка требует намного больше ресурсов чем консольный режим), а также от количества подключенных устройств к USB портам и их потребления. Значение общего потребляемого тока может вариироваться в пределах от 250мА до 1А.

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

Перед пайкой модулей и плат желательно отключить их от разъема GPIO, будет неплохо если есть возможность выполнять монтаж паяльником на напряжение 36В (или ниже) с использованием понижающего трансформатора 220В - 36В и т.п.

Подведем небольшой итог по мерам безопасности:

  • Перед работой снять с себя статический заряд;
  • Желательно выполнять пайку электроники с отключенным разъемом GPIO;
  • Не перегружать пины 3,3В (50мА) и не закорачивать их напрямую с другими пинами;
  • Не перегружать пины 5В (300-500мА) и не закорачивать их напрямую с другими пинами;
  • Исключить протекание тока величиной более 15мА через пины GPIO;
  • Исключить попадание напряжения более 3,3В на пины GPIO;
  • Подключать напрямую к Raspberry Pi не более 3х светодиодов (до 15мА каждый);
  • Внимательно проверить правильность подключения перед подачей питания на схему и малинку.

 

Уровни на пинах GPIO по умолчанию

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

После того как Raspberry Pi включена и операционная система Linux загружена, на выводах GPIO установлен низкий уровень (0В), и так до тех пор пока какая-то программа или скрипт не изменит состояние портов.

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

И все бы хорошо если бы не небольшое НО... Суть его заключается в том, что начиная с момента подачи питания на платформу и до момента инициализации драйверов в ОС, на произвольных пинах могут кратковременно присутствовать высокие уровни (3,3В).

Этот момент нужно предусматривать при проэктировании схем, подключаемых к GPIO!

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

Более детальную информаци о том как работает GPIO на платформе Raspberry Pi можно узнать из документации к процессорам Broadcom (смотри ссылки в конце статьи).

 

Светодиод и кнопка - правильное и неправильное подключение

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

Правильное и неправильное подключение светодиода к Raspberry Pi

Рис. 5. Правильное и неправильное подключение светодиода к Raspberry Pi.

Как видно из рисунка, в правильном подключении присутствует токоограничительный (гасящий) резистор, который лимитирует ток через светодиод и пин GPIO4(для примера). При прямом подключении без резистора на светодиод поступит напряжение 3,3В, что является явно больше нормы для светодиодов (2-3В). Прямое напряжение такой величины станет причиной достаточно большого тока в цепи 50+мА, что может повлечь за собою выгорание светодиода и выхода из строя как отдельного буфера GPIO, так и процессора вцелом.

Правильное и неправильное подключение кнопки к Raspberry Pi

Рис. 6. Правильное и неправильное подключение кнопки к Raspberry Pi.

Подключать кнопку к GPIO нужно используя опорное напряжение и ограничительне резисторы. Кто-то может спросить: что же это за способ такой подключения избыточный, что для подключения кнопки нужно еще два резистора, не можно ли обойтись одной кнопкой? - нет, нельзя.

И вот почему: в случае прямого подключения есть вероятность подпалить используемый выход, поскольку при инициализации системы (загрузка малинки) или неверной установке режимов порта (сконфигурирован как OUTPUT) на используемый пин может пойти +3,3В, что в свою очередь при замыкании кнопки вызовет короткое замыкание порта с землей GND.

В схеме с резисторами мы получаем вот что:

  • Пока кнопка SW1 не нажата то через резисторы R1 и R2 на входе порта установлен высокий уровень 3,3В;
  • При замыкании кнопки SW1 через резистор R1 и кнопку пойдет ток, равный I=U/R=3,3В/10000Ом=0,33мА, а через ограничивающий резистор R2 и кнопку на входе порта будет установлен низкий уровень - 0В;
  • Если пин порта выставлен неверно, на выход 3,3В - через цепочку R1, R2 не будет идти никакой ток (3,3В=3,3В), а при нажатии кнопки через R2 и SW1 потечет ток равный R=3,3В/750Ом=4,4мА, что является безопасным значением и никак не повредит схему и порт GPIO.

Резистор R1 можно установить на сопротивление 10 КОм - 20 КОм, а для резистора R2 на 600 Ом - 2 КОм, все должно уверенно работать.

Те, кто подключает кнопку так, как на перечеркнутом рисунке #6 - это экстремалы, которые осознанно или не осознанно испытывают свою удачу!

Не нужно жалеть резисторов, лучше установить последовательно к каждому пину по резистору примерно 1К и настроить схему для уверенной работы с такими значениями сопротивления, чем потом, в случае ошибки, поплатиться ценой целой платы Raspberry pi !


Расчет гасящего резистора для светодиода

Как правило, для экспериментов со светодиодами будет достаточно гасящего резистора на 270-600 Ом. При большем сопротивлении светодиод будет светиться немного тусклее, а при меньшем - ярче.

Для более точного расчета сопротивления гасящего резистора (при пиатнии от линии 3,3В) используем формулу:

R = (3,3В - Uд) / Iд,

где:

  • R - сопротивление гасящего резистора;
  • Uд - рабочее напряжение светодиода;
  • Iд - рабочий ток светодиода.

Приведу здесь типовые значения напряжения для светодиодов разного цвета:

  • красный - 1,8...2В;
  • желтый и зеленый - 2...2,4В;
  • белые и синие (яркие) - 3...3,5В.

Рабочий ток у свтеодиодов, в зависимости от типа, может колебаться в пределах 10-25мА. Для более тотчных расчетов лучше не полениться и уточнить параметры конкретного светодиода по справочнику. В нашем случае, для экспериментов, ток величиной 10-15мА будет достаточен и безопасен.

К примеру возьмем отечественный светодиод АЛ307 красного цвета и рассчитаем для него гасящий резистор при токе 10мА:

R = (3,3В - 2В) / 0,01А = 130 Ом.

При сопротивлении гасящего резистора 130 Ом и питании напряжением 3,3В светодиод будет светить достаточно ярко. Можете поэкспериментировать с сопротивлением, скорее всего что при значении 300 Ом яркости свечения будет вполне достаточно для экспериментов с GPIO в Raspberry Pi и нам не придется волноваться о перегрузке порта.

 

Схема эксперимента со светодиодом и кнопкой

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

Схема безопасного подключения кнопки и светодиода к Raspberry Pi GPIO

Рис. 7. Схема безопасного подключения кнопки и светодиода к Raspberry Pi GPIO.

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

Схема подключения переключателя и светодиода на макетной панели к малинке

Рис. 8. Схема подключения переключателя и светодиода к малинке используя макетницу.

Примечание: обе схемки, которые приведены выше, рисовались в замечательной свободной программе под именем "Fritzing". Скачать программу можно на сайте fritzing.org для операционных систем Linux, Windows, Mac OS X.

Тем, кто использует Debian GNU Linux, Ubuntu, Linux Mint для установки программы достаточно выполнить команду в консоли:

sudo apt-get install fritzing

Проект принципиальной схемы и ее разводки на панели для Fritzing : raspberry-pi-led-key-test.zip (7,4 КБ).

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

Макет эксперимента со светодиодом, кнопкой и Raspberry Pi GPIO

Рис. 9. Макет эксперимента со светодиодом, кнопкой и Raspberry Pi GPIO.

Для удобного удаленного программирования и управления к малинке подключен беспроводный Wi-Fi адаптер, о том как подключить raspberry Pi и настроить беспроводную сеть было подробно рассказано в предыдущей статье.

Сама малинка у меня запитана через понижающий стабилизатор напряжения (LM2596S), в качестве источника питания используется аккумулятор на 6В и 6А*Ч. Можно все запитать и от сетевого блока питания на 5В 2А, но у меня уже был собран тестовый стенд с питанием от аккумулятора, вот его и применил.

 

Программа для эксперимента со светодиодом и кнопкой

Если вы все уже собрали и перепроверили, то можем переходить к написанию программы. Программировать мы будем на языке Питон (Python) - это удобный, быстрый и богатый возможностями скриптовый язык программирования. После написания программы не нужно ничего компилировать, просто запускаем скрипт на исполнение и любуемся результатом.

Свечение светодиода в момент нажатия кнопки - первое что приходит на ум, но это как-то совсем не интересно. Мы реализуем программку которая заставит мерцать светодиод с частотой 2 раза в секунду (2Гц), а при нажатии кнопки частота мерцания будет увеличиваться примерно в 5 раз (10Гц) - думаю что такой пример более интеерсный чем просто нажать кнопку и засветить LED.

Для выполнения программы ее нужно сохранить в файл и потом загрузить на Raspberry Pi. Для этого сначала нужно подключиться к малинке удаленно по терминалу (SSH) или же открыть программу "Терминал" если вы работаете в графической среде ОС Raspbian прямо на своей малинке.

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

Для создания файла-программы под именем "led_key_test.py" в директории "/home/pi" и его последующего открытия для редактирования в редакторе нужно выполнить простую команду:

nano /home/pi/led_key_test.py

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

Внимание! Комментарии в коде приведены для его лучшего понимания и начинаются с символов решотки "#". Нужно удалить все комментарии с символами кириллици, иначе программа при запуске выдаст ошибку.

#!/usr/bin/env python

# Подключаем необходимые библиотеки (для задержки по времени и GPIO)
import time
import RPi.GPIO as GPIO

# Установим номера пинов GPIO, с которыми будем работать
LED = 4
KEY = 17

# Делаем сброс состояний портов (все конфигурируются на вход - INPUT)
GPIO.cleanup()
# Режим нумерации пинов - по названию (не по порядковому номеру на разъеме)
GPIO.setmode(GPIO.BCM)
# Сконфигурируем пин LED на вывод (OUTPUT)
GPIO.setup(LED, GPIO.OUT)
# Установим низкий уровень (0) на пине LED
GPIO.output(LED, GPIO.LOW)
# Сконфигурируем пин KEY на ввод (INPUT)
GPIO.setup(KEY, GPIO.IN)
# Выведем на экран текст-приветствие
print 'Hello! Blink...blink...'

# Проверка на прерывание программы с клавиатуры (CTRL+C)
try:
    # Вечный цикл
    while True:
        # Если кнопка нажата (на пине KEY низкий уровень 0V)
        if GPIO.input(KEY) == False:
            # Устанавливаем задержку 0,1 сек. и выводим сообщение
            timeout = 0.1
            print 'Key pressed.'
        else:
            # в противном случае задержка - 0,5 сек.
            timeout = 0.5
        # Засветим светодиод, подключенный к пину LED
        GPIO.output(LED, GPIO.HIGH)
        # Подождем (выполним заданную выше задержку)
        time.sleep(timeout)
        # Погасим светодиод, подключенный к пину LED
        GPIO.output(LED, GPIO.LOW)
        time.sleep(timeout)
# Если комбинация клавиш CTRL+C была нажата - сброс пинов и завершение
except KeyboardInterrupt:
    GPIO.cleanup()

Важно: в программе необходимо соблюдать отступы - каждый по 4 пробела или же одна табуляция, к примеру после "else" строчка начинается с 3х табуляций или 12 пробелов, а перед "while True:" - одна табуляция или 4 пробела (1таб=4пробела). Это важно и необходимо для правильной работы программы на Python!

Для сохранения файла и выхода из редактора нажимаем комбинацию клавиш CTRL+X, а на вопрос о сохранении файла жмем клавишу "y" и подтверждаем при помощи "ENTER".

Теперь сделаем наш скрипт исполняемым и можем запустить нашу программу, выполним команды:

chmod +x /home/pi/led_key_test.py
/home/pi/led_key_test.py

После запуска на экран будет выведено приветствие, а светодиод должне начать мигать с частотой примерно 2 раза в секунду.

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

Рис. 10. Raspberry Pi GPIO тестовая программа для светодиода и кнопки, результат работы.

Небольшое видео, демонстрирующее работу программы (18 секунд):

 

Как управлять пинами GPIO на любом языке программирования

Интерфейс GPIO, как и другие устройства в Линукс, представлен в виде директорий и файлов-устройств к которым можно обращаться за чтением, а также выполнять запись необходимых значений тем самым изменяя конфигурацию и состояние пинов порта. Данная система называется SysFS (System File System) - это виртуальная файловая система, которая предоставляется ядром Linux.

Давайте проведем краткий эксперимент, засветим и погасим светодиод, который подключен через гасящий резистор к пину под номером 15 (GPIO22). Для этого укажем драйверу что мы будем работать с пином GPIO22, зарезервируем порт на время работы (другие приложения не смогут его использовать пока мы его не освободим). Делается это при помощи команды:

echo 22 > /sys/class/gpio/export

При помощи следующей команды смотрим создался ли файл для нашего GPIO22:

ls /sys/class/gpio/

Увидим примерно вот такой список:

export  gpio22  gpiochip0  unexport

Наш пин готов к работе - появилась папка с названием gpio22. Также можем посмотреть какие файлы в папке создало ядро Linux для нашего пина (к ним можно будет обращаться - писать и считывать информацию с порта):

ls /sys/class/gpio/gpio22

На выходе команды получим:

active_low  device  direction  edge  subsystem  uevent  value

А теперь установим при помощи следующей команды направление (direction) пина GPIO22 на вывод (OUTPUT) и сразу же посмотрим второй командой все ли установилось как нужно:

echo out > /sys/class/gpio/gpio22/direction
cat /sys/class/gpio/gpio22/direction

В результате на экране должно появиться слово "out", что свидетельствует о том что все установлено верно. Теперь осталось лишь подать высокий уровень на наш пин чтобы засветить светодиод. Сделаем это выводом числа 1 в файл /sys/class/gpio/gpio22/value, используем вот такую команду:

echo 1 > /sys/class/gpio/gpio22/value

Светодиод должен зажечься. Прочитать состояние пина можно при помощи команды:

cat /sys/class/gpio/gpio22/value

А теперь погасим светодиод  - выполним команду:

echo 0 > /sys/class/gpio/gpio22/value

Ну и на последок, после всей проделанной полезной работы выполним освобождение пина GPIO22, заставим драйвер разрегистрировать его:

echo 22 > /sys/class/gpio/unexport

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

Важно помнить что после резервирования пина (export) и выполнения работ связанных с ним, его нужно разрезервировать (unexport), иначе он останется занят и другие программы и скрипты не смогут получить к нему доступ!

 

Модуль RPIO

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

RPIO - это модуль с дополнительными возможностями для работы с GPIO Raspberry Pi. Он содержит весь функционал пакета GPIO(RPi), умеет работать с перерываниями.

Также данный модуль содержит две полезные утилитки:

  • rpio-curses  - удобный консольный графический интерфейс для мониторинга и установки состояний пинов;
  • rpio - консольная утилита для установки состояний пинов, мониторинга состояний пинов и их режимов, а также для получения другой полезной информации.

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

 

Заключение

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

Что можно сделать после светодиода и кнопки? - можно подключить три светодиода и сделать небольшой бегущий огонь, также вместо светодиода можно подключить ключевой транзистор и малогабаритное электромагнитное реле, с помощью которого можно включать и выключать различные устройства с питанием от 12В или 220В. Количество вариантов ограничивается только вашей фантазией и желанием.

Полезные источники:

 (5/5) голосов: 3   просмотров: 619


Тематика:  Linux  Raspberry Pi  Python  GPIO

Комментарии к публикации (2)
crazyfrogpvl 1 crazyfrogpvl 
03 Август 2016 14:19

А можно ли на один GPIO подключить несколько кнопок задав для каждой кнопки через резисторы разный ток?

0 
ph0en1x 2 ph0en1x 
04 Август 2016 15:45

У Raspberry Pi нет встроенного Аналогово Цифрового Преобразователя (АЦП, ADC), который подключен к GPIO. Поэтому ответ на ваш вопрос - НЕТ.

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

На выводах GPIO может быть только логический 0 (0В) или 1 (3,3В), чередуя эти сигналы и с некоторой задержкой по времени можно кодировать и принимать/передавать различную информацию.

К малинке можно подключить АЦП, к примеру на микросхеме PCF8591 - интерфейс i2C, микросхема имеет 4 аналоговых входа и 1 аналоговый выход. Здесь уже можно подключить десяток кнопок через резисторы, переменный резистор, фото-резистор, термо-резистор, индикатор уровня сигнала на выход, схему плавного управления мощностью нагревателя и другие источники аналогового сигнала и все это можно будет читать и управлять используя 2 пина шины I2C.

Специально для подключения множества кнопок/светодиодов/ключей есть микросхема-расширитель ввода-вывода с интерфейсом I2C - PCF8574(PCF8575). Используя ее можно подключить к Raspberry Pi цифровую клавиатуру, матрицу из светодиодов и т.п.

Всего суммарно к пинам шины I2C можно подключить до 127 устройств, которые умеют работать с данным интерфейсом!

+1 

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