Знакомимся с RepkaPi.GPIO SysFS. Разбираем подтягивающие резисторы, прерывания и примеры работы

Содержание

• Введение
• Методы библиотеки для работы с прерываниями/событиями
• Таблица основных параметров работы с GPIO
• Подтяжка GPIO
  • Для чего нужна подтяжка?
  • Пример 1: Использование подтяжки, работа с режимами Input и Output
  • Подбор подтягивающего резистора
• Пример 2: GPIO.wait_for_edge(). Блокируем выполнения программы до наступления события на пине
• Пример 3. GPIO.add_event_detect, GPIO.event_detected и remove_event_detect Регистрируем событие и проверяем было ли выполнено данное событие.
• Пример 4. add_event_callback(), использование вызова callback функций при обработки событий
• Устранение дребезга в обработке прерываний

Введение

Первая статья по библиотеке RepkaPi.GPIO

Данная библиотека совместима по методам с библиотекой RPI.GPIO

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

1. Для начала рекомендуем ознакомиться с первой статьей.
2. Для работы нам понадобится
3. Светодиоды на 3-5В
4. Резисторы на 100Ом, 220Ом и 10кОм
5. Кнопки тактовые
6. Макетная плата
7. Набор кабелей DuPont мапа-папа
8. Можно взять переходник и шлейф от Raspberry Pi для макетной платы

Для удобства подготовлены печатные шаблонны распиновки Repka Pi 3

Скачать PDF файл шаблона

Левую картинку можно надеть на пины (для удобства лучше взять переходник или гребенку GPIO)

Правая картинка для переходника от Raspberry Pi

У меня под рукой оказалась как гребенка, так и переходник

Для удобства ссылки на AliExpress

• Удлинённый GPIO - https://aliexpress.ru/item/4000909983791.html
• Переходник, макетка и шлейф - https://aliexpress.ru/item/32596465282.html
• Гребенка разветвитель Г образный - https://aliexpress.ru/item/1005004771198406.html
• Провода DuPont - https://aliexpress.ru/item/1005002000655439.html
• Набор перемычек - https://aliexpress.ru/item/32833662012.html

Если у вас есть опыт заказа печатных плат, то для Вас мы подготовили серию плат по GPIO, в том числе и переходник. Все платы разработаны в EasyEDA и опубликованы на oshwlab.com

Информационные накладки

Скачать: https://oshwlab.com/dikshv/repka-pi-gpio-board

LED тестер

Скачать: https://oshwlab.com/dikshv/repkapi-led-tester-pcb

Переходник на макетную плату Т-образный

Скачать: https://oshwlab.com/dikshv/repka-pi-3-gpio-for-devboard

Приступим к изучению. В данной статье все примеры будут выполняться на таком стенде

Методы библиотеки для работы с прерываниями/событиями

В предыдущей статье мы рассмотрели основные методы и константы библиотеки

• GPIO.wait_for_edge() - блокирует выполнение вашей программы до тех пор, пока не наступит заданное событие, принимает значения

  • channel - номер пина в соответствие с установленным режимом нумерации
  • trigger— событие, может принимать 3 значения: GPIO.RISING, GPIO.FALLING, GPIO.BOTH (смотрите описание в предыдущей статье)
  • bouncetime (не обязательный параметр) — время фильтрации дребезга в миллисекундах (Данный параметр в RepkaPi.GPIO SysFS не реализован)
  • timeout (не обязательный параметр) — время в миллисекундах, после истечения которого исполнение программы продолжится в любом случае.

• GPIO.event_detected() – проверяет наступили ли событие определенное функцией GPIO.add_event_detect, принимает значение

  • channel - номер пина в соответствие с установленным режимом нумерации

    Возвращает

    • True — с начала наблюдения, заданное событие наступало
    • False — с начала наблюдения, заданное событие не наступало

• GPIO.add_event_detect() – регистрирует отслеживание события на пине, на один пин можно зарегистрировать только один обработчик, принимает значения

  • channel - номер пина в соответствие с установленным режимом нумерации
  • trigger— событие, может принимать 3 значения: GPIO.RISING, GPIO.FALLING, GPIO.BOTH (смотрите описание в предыдущей статье)
  • callback (не обязательный параметр) - функция, которая должна быть вызвана при наступлении заданного события
  • bouncetime (не обязательный параметр) — время фильтрации дребезга в миллисекундах

• GPIO.add_event_callback() - добавляющая дополнительный обработчик-функцию к уже существующему отслеживанию, принимает значения

  • channel - номер пина в соответствие с установленным режимом нумерации
  • callback - функция, которая должна быть вызвана при наступлении заданного события

• GPIO.remove_event_detect() – удаляет все зарегистрированные обработчики с пина, принимает значение

  • channel - номер пина в соответствие с установленным режимом нумерации

Таблица основных параметров работы с GPIO

Подтяжка GPIO

Давайте немного поговорим о подтяжке GPIO и в каком состояние они находятся по умолчанию.

В данной схеме показана в каком состояние находится и какое состояние может применять тот или иной пин.

Данная схема предназначена для плат первых выпусков, платы начиная с версии 1.5 и последние выпуски версии 1.4 стали выпускаться со схемой ниже. Отличие только в пинах 27 и 28, была убрана физическая подтяжка к 3.3В через резистор 2К

Состояние Z - это высокоимпедансное состояние или высокоомное состояние, или состояние «Выключено», другими словами это отключенный проводник. А отключают его для того что бы не было короткого замыкания.

Пины 8 и 10 используются для DEBUG-UART и применять их для работы в режиме ввода/вывода не рекомендуется, данные пины имеют такую схему

Так же обратите внимание что пины 3 и 5 имеющие интерфейс i2c имеют подтяжку к 3.3В через резистор 2К

Для чего нужна подтяжка?

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

Чтобы обойти эту проблему, мы используем подтягивающий или понижающий резистор. Таким образом, можно установить значение входа по умолчанию. Резисторы повышения/понижения можно использовать аппаратное и с помощью программного обеспечения. В аппаратном обеспечении обычно используется резистор 10 кОм между входным каналом и напряжением 3,3 В (повышение) или 0 В (понижение).

Пример 1: Использование подтяжки, работа с режимами Input и Output

Предлагаю сразу перейти к примерам работы GPIO в режиме Input и Output. При нажатии кнопки будет загораться Диод, данный пример Вы так же можете посмотреть в файле Demo/pull_up_down.py

В первой части статьи мы уже рассматривали теорию и какие есть функции работы библиотеки RepkaPi.GPIO и не будем повторяться и описывать функции.

Рассмотрим следующую схему

В данной схеме кнопка подключена к Pin 15 и имеет подтягивающий (стягивающий) резистор 10Ком к земле.

Схема будет работать так, если кнопка не нажата, то состояния пина 15 будет 0 (GPIO.LOW/False) так как он будет подключён к земле и как только произойдет замыкание на кнопки (нажатие) на пин 15 пойдет ток 3.3В и пин примет состояние 1 (GPIO.HIGH/True).

Теперь подключаем светодиод к Pin 12 через защищающий резистор, резистор может быть 100-220Ом в зависимости от того какой вы выбрали светодиод, он нужен для защиты диода от перегорания

На вашей макетной плате это может выглядит примерно так

Теперь рассмотрим Листинг скрипта, который будет обрабатывать нажатие кнопки

import RepkaPi.GPIO as GPIO

from time import sleep          # позволяет выставить задержку на время

GPIO.setboard(GPIO.REPKAPI3)    # Repka Pi 3
GPIO.setmode(GPIO.BOARD)        # выбираем тип обращения к GPIO по номеру PIN (BOARD)
button = 15                     # устанавливаем pin 15 для кнопки
led = 12                        # устанавливаем pin 12 для диода
GPIO.setup(button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)    # устанавливаем кнопка как input
GPIO.setup(led, GPIO.OUT)       # устанавливаем диод (LED) как output

try:
    while True:                 # цикл будет выполняться пока не нажмем CTRL+C
        if GPIO.input(button) == 1:      # if button == 1
            print (f'PIN {button} равен 1/HIGH/True - LED ON')
            GPIO.output(led, 1) # выставляем pin led 1/HIGH/True
        else:
            print (f'PIN {button} равен 0/LOW/False - LED OFF')
            GPIO.output(led, 0) # выставляем pin led 0/LOW/False
        sleep(0.1)              # задержка 0.1 секунда

finally:                        # выполняет блок инструкций в любом случае, было ли исключение, или нет
    print("Завершение.")
    GPIO.output(led, 0)         # выставляем pin led 0/LOW/False
    GPIO.cleanup()              # убираем все настойки по GPIO

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

Так же можно сделать подтяжку на 3.3В, тогда у нас на Pin 15 состояние по умолчанию будет 1 (GPIO.HIGH/True), а при замыкании кнопки (нажатие) состояние сменится на 0 (GPIO.LOW/False) и диод будет гореть до тех пор, пока не будет нажата кнопка, получится обратная логика работы

И схема

Теперь давайте разберемся как нам подобрать подтягивающий резистор к Вашей задачи.

Подбор подтягивающего резистора

Если вам это не интересно, то можно перейти к следующему примеру и пропустить эту часть по данной ссылке

Представим нашу схему таким образом

Это простая схема «Резистивного делителя напряжения» где U это наш ток 3.3В, R1 – какая-то нагрузка в нашем случае это кнопка которая имеет сопротивление 0Ом или блика к этому значению, R2 – это подтягивающий резистор 10КОм, U1 – напряжение которое будет на пине.

Простейший резистивный делитель напряжения представляет собой два последовательно включённых резистора R1 и R2, подключённых к источнику напряжения U. Поскольку резисторы соединены последовательно, то ток через них будет одинаков в соответствии с первым правилом Кирхгофа. Падение напряжения на каждом резисторе согласно закону Ома будет пропорционально сопротивлению (ток, как было установлено ранее, одинаков):

Для каждого резистора имеем:

Сложив выражения, получаем:

Далее:

Из этого следует:

Источник Резистивный делитель напряжения

Теперь давайте разберемся какое будет напряжение U1 или U2 на пине от этого зависит логический уровень. Для этого преобразуем схему для понимания

Через резистор R1 и R2 протекает одинаковый ток пока к выходу ничего не подключено, а сумма сопротивлений двух резисторов при последовательном соединение равна:

10КОм=10000Ом

Теперь рассчитаем силу тока, протекающего через резисторы

Теперь, когда у нас есть сила тока и известно сопротивление R2

Приведем формулу к общему виду

Таким образом мы рассчитали, что при нажатии кнопки на пине будет напряжение 3.3В что означает высокий уровень 1/GPIO.HIGH/True

Теперь рассчитаем второй пример если подтяжка у нас будет к 3.3В, а нажатие кнопки должен быть логически 0/GPIO.LOW/False

R1=10000Ом, а R2=0Ом

0В является нижним уровнем 0/GPIO.LOW/False

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

Как быть если нужно подключить не кнопку, а датчик или другой элемент замыкания, который имеет свое сопротивлений. И тут уже нужно добиться что бы при срабатывании датчика напряжение было выше +2,4В для логической единицы и примерно до +0,99В считается логическим нулем. И тут нужно помнить, чем ближе напряжение к 3,3В или 0В тем меньше помех.

Давайте теперь предположим, что у нас подключен датчик, который имеет внутреннее сопротивление 80КОм.

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

как видим, что если наш датчик сработает, то все равно останется логический ноль.

В таких ситуациях нужно подбирать подтягивающее сопротивление.

Давайте теперь подтягивающий резистор заменим на 100КОм

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

Тут лучше поставить сопротивление больше в 6 раза, т.е. примерно 480КОм

И такой результат уже будет гарантированная логическая единица.

Давайте теперь быстро рассмотрим эти же примеры при подтяжке к 3.3В, а при срабатывании датчика у нас должен быть логический ноль или напряжение на пине ближе к 0В.

Заменим R2 на 80КОм

R1=10000Ом, а R2=80000Ом

И при подтяжке к 3.3В как видим при таком внутреннем сопротивление результат работы датчика будет не заметен. Теперь подтягивающий резистор так же заменим на 100КОм

Тут уже будет логический ноль, но тут так же рекомендую ставить подтягивающий резистор примерно в 6 раз больше чем внутреннее сопротивление датчика, 480КОм

И тут уже гарантированный логический ноль.

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

И так мы разобрались как работает подтяжка и для чего она нужна.

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

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

Так же в нашем примере используется токоограничительного («зашитного») на светодиоде, как его рассчитать хорошо было описано в другой статье в нашем блоге

Пример 2: GPIO.wait_for_edge(). Блокируем выполнения программы до наступления события на пине

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

Схема у нас остается прежней, но изменится код программы таким образом, данный пример Вы так же можете посмотреть в файле Demo/wait_for_edge.py

import RepkaPi.GPIO as GPIO


GPIO.setboard(GPIO.REPKAPI3)    # Repka Pi 3
GPIO.setmode(GPIO.BOARD)        # выбираем тип обращения к GPIO по номеру PIN (BOARD)
button = 15                     # устанавливаем pin 15 для кнопки
led = 12                        # устанавливаем pin 12 для диода
GPIO.setup(button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)    # устанавливаем кновка как input
GPIO.setup(led, GPIO.OUT)       # устанавливаем диод (LED) как output

try:
    GPIO.wait_for_edge(button, GPIO.RISING)    # ждем пока логический ноль не сменится логической единицей на пине 15 (нажатие кнопки)
    GPIO.output(led, 1) # выставляем pin led 1/HIGH/True

    GPIO.wait_for_edge(button, GPIO.RISING, timeout=10000) # ждем пока логический ноль не сменится логической единицей на пине 15 (нажатие кнопки) или не пройдет 10 секунд
    GPIO.output(led, 0) # выставляем pin led 0/LOW/False

    #контроль того, что вывело из функции wait_for_edge() осуществляется так:
    channel = GPIO.wait_for_edge(button, GPIO.RISING, timeout=5000)
    if channel is None:
       print('Произошел тайм-аут')
    else:
       print('Сигнал обнаружен на канале', channel)

finally:                        # выполняет блок инструкций в любом случае, было ли исключение, или нет
    print("Завершение.")
    GPIO.output(led, 0)         # выставляем pin led 0/LOW/False
    GPIO.cleanup()              # убираем все настойки по GPIO

Пример 3. GPIO.add_event_detect, GPIO.event_detected и remove_event_detect Регистрируем событие и проверяем было ли выполнено данное событие.

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

Схема у нас остается по-прежнему такая же, как и в предыдущих примерах, меняем код, данный пример Вы так же можете посмотреть в файле Demo/add_event_detect.py, а также есть еще пример в файле Demo/event_detected.py

import RepkaPi.GPIO as GPIO

from time import sleep          # позволяет выставить задержку на время


GPIO.setboard(GPIO.REPKAPI3)    # Repka Pi 3
GPIO.setmode(GPIO.BOARD)        # выбираем тип обращения к GPIO по номеру PIN (BOARD)
button = 15                     # устанавливаем pin 15 для кнопки
led = 12                        # устанавливаем pin 12 для диода
GPIO.setup(button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)    # устанавливаем кнопка как input
GPIO.setup(led, GPIO.OUT)       # устанавливаем диод (LED) как output


try:
    GPIO.add_event_detect(button, GPIO.RISING) # Добавляем детектирование события - нажатие кнопки

    # любой другой код, можно добавить сюда
    sleep(5)            # Для демонстрации делаем задержку на 5 секунд

    if GPIO.event_detected(button):             # Если в течение 5 секунд была нажата кнопка, то загорится светодиод
        GPIO.remove_event_detect(button)        # Удаляем все обработчики прерывания с кнопки
        GPIO.output(led, 1)
        GPIO.wait_for_edge(button, GPIO.RISING, timeout=5000) # Выход по нажатию кнопки или через 5 секунд

except KeyboardInterrupt:
    print("Выход по Ctrl+C")                # Выход из программы по нажатию Ctrl+C
finally:                        # выполняет блок инструкций в любом случае, было ли исключение, или нет
    print("Завершение.")
    GPIO.output(led, 0)         # выставляем pin led 0/LOW/False
    GPIO.cleanup()              # убираем все настойки по GPIO

Пример 4. add_event_callback(), использование вызова callback функций при обработки событий

Задача по-прежнему у нас не меняется. Управление светодиодом по нажатию кнопки.

Библиотека позволяет «по вешать» функцию на зарегистрированный обработчик событий. Как мы уже рассмотрели в предыдущем примере то что зарегистрированное событие через функцию add_event_detect() обрабатывается в отдельно запущенном параллельном процессе обработчика и не мешает ходу выполнения программы, привязанные функции так же будут обрабатываться в данном потоке. . Тут есть еще такой момент что на один пин можно зарегистрировать только один обработчик! Но можно определять несколько callback функций на один обработчик и как это сделать будет показано в данном примере.

Есть 2 способа привязать функцию к обработчику

1. передать в параметре callback метода add_event_detect нашу функцию
2. использовать метод add_event_callback(), данный метод так же позволяет привязывать сразу несколько функций к обработчику

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

О «дребезге» мы поговорим в следующей главе.

Более подробно и все способы определения функции приведены в этом примере, данный пример Вы так же можете посмотреть в файле Demo/add_event_callback.py

import RepkaPi.GPIO as GPIO

from time import sleep          # позволяет выставить задержку на время


GPIO.setboard(GPIO.REPKAPI3)    # Repka Pi 3
GPIO.setmode(GPIO.BOARD)        # выбираем тип обращения к GPIO по номеру PIN (BOARD)
button = 15                     # устанавливаем pin 15 для кнопки
led = 12                        # устанавливаем pin 12 для диода
GPIO.setup(button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)    # устанавливаем кнопка как input
GPIO.setup(led, GPIO.OUT)       # устанавливаем диод (LED) как output

def callback_func1(pin):
    print("Вызывается первая функция-обработчик на пине: "+str(pin))

def callback_func2(pin):
    print("Вызывается вторая функция-обработчик на пине: "+str(pin))

def callback_func_led1(pin):
    GPIO.output(led, 1) # выставляем pin led 1/HIGH/True

def callback_func_led2(pin):
    GPIO.output(led, 0)         # выставляем pin led 0/LOW/False

try:
    print("Пример 1")
    GPIO.add_event_detect(button, GPIO.RISING, callback=callback_func1) # Добавляем детектирование события с функцией-обработчиком callback_func1, нажатие кнопки

    # Добавлять дополнительные функции-обработчики можно при помощи add_event_callback()
    GPIO.add_event_callback(button, callback=callback_func2)            # Добавляем дополнительный обработчик события - функцию callback_func2

    # любой другой код, можно добавить сюда
    sleep(5)            # Для демонстрации делаем задержку на 5 секунд

    GPIO.remove_event_detect(button)        # Удаляем все обработчики прерывания с кнопки

    print("Пример 2")

    # Можно сначала добавить детектирование, а потом прикрутить обработчики
    GPIO.add_event_detect(button, GPIO.RISING)                            # Добавляем детектирование события, нажатие кнопки
    GPIO.add_event_callback(button, callback=callback_func_led1)               # Добавляем обработчик события - функцию callback_func_led1
    GPIO.add_event_callback(button, callback=callback_func_led2)               # Добавляем обработчик события - функцию callback_func_led2
    sleep(5)            # Для демонстрации делаем задержку на 5 секунд
    GPIO.remove_event_detect(button)        # Удаляем все обработчики прерывания с кнопки

    print("Пример 3")
    GPIO.add_event_detect(button, GPIO.BOTH, lambda pin: GPIO.output(led, GPIO.input(button)))  # При нажатии кнопки светодиод будет загораться
    sleep(5)            # Для демонстрации делаем задержку на 5 секунд
    GPIO.remove_event_detect(button)        # Удаляем все обработчики прерывания с кнопки

    print("Пример 4")
    # Устраняем дребезги в обработке, параметр bouncetime

    GPIO.add_event_detect(button, GPIO.RISING, bouncetime=50)                  # Добавляем детектирование события, нажатие кнопки и устанавливаем дребезг 50 мс
    GPIO.add_event_callback(button, callback=callback_func1)               # Добавляем обработчик события - функцию callback_func1
    GPIO.add_event_callback(button, callback=callback_func2)               # Добавляем обработчик события - функцию callback_func2

    sleep(5)            # Для демонстрации делаем задержку на 5 секунд
    GPIO.remove_event_detect(button)        # Удаляем все обработчики прерывания с кнопки

    print("Пример 5")

    # Можно применить и такую конструкцию

    GPIO.add_event_detect(button, GPIO.RISING, callback=callback_func1, bouncetime=500) # Добавляем детектирование события с функцией-обработчиком callback_func1, нажатие кнопки и устанавливаем дребезг 500 мс

    GPIO.add_event_callback(button, callback=callback_func2)            # Добавляем дополнительный обработчик события - функцию callback_func2

    # любой другой код, можно добавить сюда
    sleep(5)            # Для демонстрации делаем задержку на 5 секунд

    GPIO.remove_event_detect(button)        # Удаляем все обработчики прерывания с кнопки

   

except KeyboardInterrupt:
    print("Выход по Ctrl+C")                # Выход из программы по нажатию Ctrl+C
finally:                        # выполняет блок инструкций в любом случае, было ли исключение, или нет
    print("Завершение.")
    GPIO.output(led, 0)         # выставляем pin led 0/LOW/False
    GPIO.cleanup()              # убираем все настойки по GPIO

Устранение дребезга в обработке прерываний

Давайте разберемся что такое дребезг и как с ним бороться. Будем рассматривать все на том же примере с кнопкой и светодиодом.

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

Давайте из кода уберем задержку sleep(0.1) и выполним его еще раз, то в консоли можно заметить такое.

Это и есть дребезг. Дребезг может возникать не при каждом нажатие.

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

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

Дребезг контактов (англ. bounce — дребезг, debounce — устранение дребезга) — явление, происходящее в электромеханических коммутационных устройствах, длящееся некоторое время после замыкания электрических контактов и состоящее из многократных неконтролируемых замыканий и размыкании контактов, обусловленных упругостью материалов и деталей контактной системы — некоторое время контакты «подпрыгивают» при соударениях, размыкая и замыкая электрическую цепь.

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

И это можно решить программным путем. В Примере 4 есть такая строчка

GPIO.add_event_detect(button, GPIO.RISING, bouncetime=50)
GPIO.add_event_callback(button, callback=callback_func1)

В данной методе мы регистрируем событие на кнопку при изменении ее значения с LOW на HIGH, то есть по фронту GPIO.RISING и выставляем bouncetime=50, т.е. проверка смены состояния пина будет отложена на 50 миллисекунд

Но при решение программным путём есть вероятность получить не тот результат особенно при использовании отслеживания по фронту и по спаду (GPIO.RISING и GPIO.FALLING). Так происходит потому что фильтрация наступает уже после наступления события и это может привести к тому что следующее прерывание будет отработано не корректно.

И это нужно учитывать в логики программы. Здесь можно попробовать использовать GPIO.BOTH и в функции реализовать дополнительную проверку состояния пина.

Детектируем изменение сигнала в любом направление

GPIO.add_event_detect(button, GPIO. BOTH, bouncetime=50)

И функцию дорабатываем таким образом

def callback_func1(pin):
    if not GPIO.input(pin):
        print("Вызывается первая функция-обработчик на пине: "+str(pin))

Заключение

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

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