Проект “RFID-сейф” на базе одноплатного компьютера Repka PI 4

Содержание #

1. Введение
2. Электрическая принципиальная схема
3. Монтажная схема
4. Сборка проекта
5. Запуск проекта
6. Программная реализация
7. Практическая значимость проекта
8. Расширение проекта
9. Видеообзор проекта

Введение #

Представляю вам образовательный проект — “RFID-сейф”, разработанный в рамках учебно-методического комплекса на базе одноплатного компьютера Repka PI 4.

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

Проект будет собираться с использованием “Учебно-методический комплекс REPKA”. Схему сборки можно найти в разделе "Примеры готовых проектов" учебного пособия УМК “REPKA”.

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

Используемые в проекте компоненты

1. Сервопривод MG90S используется для управления механизмом замка сейфа, см. рисунок 1.

2. Модуль RFID RC-522 используется для считывания данных с RFID меток или карт, см. рисунок 2. Каждая карта или метка имеет уникальный UID (идентификатор), который модуль может считать при поднесении.

3. Дисплей OLED 0.96" I2C используется для отображения информации о состоянии системы безопасности.

Ссылки на модули приведены в таблице ниже.

Компонент	Ссылка на приобретение
Монтажная/макетная плата	Ссылка
Шлейф	Ссылка
Переходник с шлейфа на макетную плату	Ссылка
Соединительные провода	Провода соединительные м-п Провода соединительные п-п Провода соединительные п-п
Сервопривод MG90S	Ссылка
RFID RC-522	Ссылка
Дисплей OLED 0.96" I2C	Ссылка

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

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

Для разработки кода будет использоваться текстовый редактор Geany, который входит в состав стандартного ПО Репка ОС.

Электрическая принципиальная схема

Монтажная схема

Сборка проекта

1. Подключение сервопривода MG90S

Как видно из рисунков 4 и 5 сервопривод MG90S подключается через GPIO25 и питается от 5V.

1.1. Подключаем MG90S к макетной плате согласно таблице 1:

Макетная плата	MG90S
5V	VIN
GND	GND
GPIO25	PWM

Таблица 1. Подключение MG90S к макетной плате.

1.2.  Результат подключения будет выглядеть следующим образом, см. рисунок 6:

2. Для проверки правильности подключения используем Python скрипт из репозитория repka-pi_iot-examples.

2.1. Клонируем репозиторий:

git clone git@gitflic.ru:repka_pi/repka-pi_iot-examples.git

2.2. Переходим в репозиторий:

cd repka-pi_iot-examples/

2.3. Выполним установку зависимостей.

2.3.1. Если хотите установить зависимости только для сервопривода MG90S, выполните:

make setup-MG90S

2.3.2. Если хотите установить зависимости для всех датчиков и проектов, выполните:

make setup-all

2.4. Запускаем скрипт для проверки:

make MG90S

2.4.1. Если нет никакой реакции, то проверьте номер GPIO указанный в скрипте по пути devices/executive/MG90S_example/py

TX_GPIO = 11  # Номер GPIO-пина, к которому подключён сигнальный вывод сервопривода

2.4.2. Обратимся к пособию УМК “REPKA”, в котором представлена распиновка Repka PI 4 (рисунок 7).  Из нее следует, что уникальный идентификатор порта GPIO25 равен 359 и находится на физическом пине 22.

TX_GPIO = 22  # Номер GPIO-пина, к которому подключён сигнальный вывод сервопривода

2.5. Как показано на рисунке 8, скрипт был успешно выполнен, и при установке значения в диапазоне от 500 до 2500, сервопривод выполняет поворот.

3. Подключение модуля RFID RC-522.

Как видно из рисунков 4 и 5 RFID RC-522 подключается через SPIA интерфейс и питается от 3V.

3.1. Подключим RFID RC-522 к макетной плате согласно таблице 3:

Макетная плата	RC-522
3.3V	3.3V
GPIO17	RST
GND	GND
SPIMISO	MISO
SPIMOSI	MOSI
SPICLK	SCK
SPICEO	SDA

Таблица 3. Подключение RFID RC-522  к макетной плате.

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

4. Аналогично пункту 2 выполним проверку подключения устройства.

4.1. Если ранее не устанавливали все зависимости командой setup-all, то установим зависимости для RFID RC-522  модуля, выполнив:

make setup-RC-522

4.2. Запустим python скрипт:

make RC-522

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

5. Подключение дисплея OLED 0.96″ I2C.

Как видно из рисунков 6 и 7 устройство подключается через интерфейс I2C и питается от 5V.

5.1. Подключим дисплей OLED 0.96″ I2C к макетной плате согласно таблице 4.

Макетная плата	Дисплей OLED 0.96″ I2C
5V	VDD
GND	GND
SCL1	SCK
SDA1	SDA

Таблица 4. Подключение дисплея OLED 0.96″ I2C к макетной плате.

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

6. Аналогично пункту 2 выполним проверку подключения устройства.

6.1. Если ранее не устанавливали все зависимости командой setup-all, то установим зависимости для дисплей  модуля, выполнив:

make setup-OLED-SSD1306

6.2. Запустим python скрипт:

make OLED-SSD1306

6.3. Из рисунка 12 видим, что скрипт успешно выполнился, тестовый текст появился на дисплее.

Запуск проекта

Теперь, когда все компоненты подключены, можно запустить проект "RFID-сейф". Для этого в репозитории repka-pi_iot-examples выполняем команду:

make rfid-safe

После запуска на дисплее мы можем наблюдать статус замка, как показано на рисунке 13 и 14. Также при поднесении RFID ID метки замок в виде сервопривода будет открываться или закрываться.

В программе предусмотрена защита от несанкционированных меток: только разрешённые метки могут активировать замок, см. рисунок 15. Разрешённые метки указаны в скрипте по пути repka-pi_iot-examples/sample_projects/rfid_safe_demo:

# UID допустимой карты

AUTHORIZED_UID = ["C5", "2E", "B0", "05"]  # Замените на реальный UID вашей карты для авторизации

Вы можете собрать более бюджетную версию данного проекта.

Для более бюджетной реализации проекта можно обойтись без активного охлаждения, используя Repka Pi 4 в стандартной комплектации, а также макетную плату без внешнего источника питания — при этом остальные компоненты остаются неизменными. Макетную плату можно приобрести здесь.

Для подключения нам потребуется “Распиновка портов на 40 pin разъёме на Repka Pi 4“, см. рисунок 7.

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

7. Подключаем MG90S к к Repka Pi 4 согласно таблице 1:

Проверка подключения MG90S осуществляется аналогично пункту 2.

8. Подключим RFID RC-522 к Repka Pi 4 согласно таблице 3:

Проверка подключения MG90S осуществляется аналогично пункту 4.

9. Подключим дисплей OLED 0.96″ I2C к Repka Pi 4 согласно таблице 4.

Проверка подключения OLED 0.96″ I2C осуществляется аналогично пункту 6.

Для снижения нагрузки на линию 5 В одноплатного компьютера Repka Pi 4, рекомендуется использовать дополнительное питание 5 В:

А. Подключение с использованием лабораторного блока питания:

Б. Подключение с использованием аккумуляторного блока питания:

Программная реализация #

Программное обеспечение является ядром нашего RFID-сейфа, координируя работу всех аппаратных компонентов — от считывания RFID-меток до управления замком и отображения информации. В этом разделе мы подробно разберем логику работы системы и различные подходы к ее реализации на Python и C.

Алгоритм работы #

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

Описание алгоритма:

1. Старт и инициализация: При запуске программа инициализирует все аппаратные модули (RFID, OLED, GPIO) и немедленно переходит в безопасное состояние: замок закрывается, а на дисплей выводится приветственное сообщение и приглашение приложить карту.
2. Состояние "Заблокировано" (Основной цикл):
   • Система непрерывно ожидает появления RFID-карты в поле считывателя.
   • При обнаружении карты считывается ее уникальный идентификатор (UID).
   • Считанный UID сравнивается с эталонным значением, сохраненным в программе (AUTHORIZED_UID).
   • Если UID не совпадает: На дисплей выводится сообщение "Доступ запрещен". Система остается в состоянии "Заблокировано".
   • Если UID совпадает: Доступ разрешается. Система подает сигнал сервоприводу на открытие замка и переходит в состояние "Разблокировано".
3. Состояние "Разблокировано":
   • На дисплей выводится сообщение о том, что сейф открыт, и предложение приложить ту же карту для блокировки.
   • Система снова ожидает карту. При сканировании UID сравнивается с UID карты, которой был открыт сейф.
   • Если приложена другая карта: Выводится сообщение об ошибке. Сейф остается открытым.
   • Если приложена та же самая карта: Система подает сигнал сервоприводу на закрытие замка и возвращается в состояние "Заблокировано".

Этот алгоритм обеспечивает интуитивно понятное и безопасное управление сейфом.

---

Реализация на Python #

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

1. Функциональный подход #

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

Импорты и глобальные константы

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

from periphery import SPI, GPIO
from luma.core.interface.serial import i2c
from luma.oled.device import sh1106
from PIL import Image, ImageDraw, ImageFont
import time

# Пины и настройки
SPI_DEVICE = "/dev/spidev0.0"      # Путь к устройству SPI
RST_PIN = 111                      # Пин для сброса RFID модуля
SERVO_GPIO = 359                   # Пин для управления сервоприводом
OLED_ADDR = 0x3C                   # Адрес OLED-дисплея

# UID допустимой карты
AUTHORIZED_UID = ["C5", "2E", "B0", "05"] # Замените на реальный UID вашей карты

Объяснение: Мы импортируем SPI и GPIO из библиотеки periphery для низкоуровневого управления аппаратными интерфейсами. luma.core и luma.oled предоставляют удобный инструментарий для работы с дисплеем, а PIL (Pillow) используется для рисования текста на нем. Определение всех настроек (пины, адреса, UID) в виде констант в начале файла — это хорошая практика, так как позволяет легко изменять конфигурацию проекта в одном месте.

Управление OLED-дисплеем

Далее инициализируется дисплей и создается универсальная функция для вывода на него информации.

# === OLED ИНИЦИАЛИЗАЦИЯ ===
serial = i2c(port=1, address=OLED_ADDR)
oled = sh1106(serial)
font = ImageFont.truetype("/usr/share/fonts/truetype/freefont/FreeSans.ttf", 14)

def show_message(line1, line2=""):
    image = Image.new("1", oled.size)
    draw = ImageDraw.Draw(image)
    draw.rectangle((0, 0, oled.width, oled.height), outline=0, fill=0)
    draw.text((0, 0), line1, font=font, fill=255)
    draw.text((0, 15), line2, font=font, fill=255)
    oled.display(image)

Объяснение: Сначала создается объект I2C-интерфейса, который затем передается конструктору sh1106 для создания объекта самого дисплея. Функция show_message инкапсулирует всю логику отрисовки: создает в памяти пустое черное изображение, рисует на нем две строки текста и отправляет готовое изображение на физический экран. Это удобная "обертка", которая избавляет от необходимости повторять этот код в основной логике программы.

Управление сервоприводом (Замком)

Этот блок отвечает за механическое движение замка.

# === СЕРВОПРИВОД ===
def move_servo(position_us=1500, duration_ms=1000):
    pwm_frequency = 50
    period = 1.0 / pwm_frequency
    high_time = position_us / 1_000_000
    low_time = period - high_time
    gpio = GPIO(SERVO_GPIO, "out")
    try:
        end_time = time.time() + (duration_ms / 1000)
        while time.time() < end_time:
            gpio.write(True)
            time.sleep(high_time)
            gpio.write(False)
            time.sleep(low_time)
    finally:
        gpio.write(False)
        gpio.close()

def open_lock():
    move_servo(2200, 1500)

def close_lock():
    move_servo(800, 1500)

Объяснение: Центральной является функция move_servo. Она реализует программный ШИМ (PWM), так как стандартные GPIO не поддерживают его аппаратно. Она 50 раз в секунду (стандарт для сервоприводов) подает на пин короткий импульс высокого напряжения. Длительность этого импульса (position_us в микросекундах) определяет угол поворота вала сервопривода. Функции open_lock и close_lock — это простые обертки, вызывающие move_servo с заранее подобранными значениями для поворота замка в крайние положения.

Взаимодействие с RFID-модулем

Это наиболее низкоуровневая часть программы, отвечающая за общение с чипом MFRC522 по протоколу SPI.

# === RFID ===
spi = SPI(SPI_DEVICE, 0, 1000000)
rst = GPIO(RST_PIN, "out")

def write_reg(addr, val):
    spi.transfer([(addr << 1) & 0x7E, val])

def read_reg(addr):
    return spi.transfer([((addr << 1) & 0x7E) | 0x80, 0])[1]

def set_bit_mask(reg, mask):
    write_reg(reg, read_reg(reg) | mask)

def clear_bit_mask(reg, mask):
    write_reg(reg, read_reg(reg) & (~mask))

def reset():
    rst.write(True); time.sleep(0.05)
    rst.write(False); time.sleep(0.05)
    rst.write(True); time.sleep(0.05)

def init_rfid():
    reset()
    write_reg(0x01, 0x0F); time.sleep(0.05)
    write_reg(0x2A, 0x8D); write_reg(0x2B, 0x3E); write_reg(0x2D, 30);
    write_reg(0x2C, 0); write_reg(0x15, 0x40); write_reg(0x11, 0x3D);
    write_reg(0x01, 0x00)

def antenna_on():
    val = read_reg(0x14)
    if not (val & 0x03):
        write_reg(0x14, val | 0x03)
        
def request():
    # ... (полный код функции request)
    
def anticollision():
    # ... (полный код функции anticollision)

Объяснение: Здесь реализуется протокол обмена данными с RFID-модулем. Функции write_reg и read_reg являются базовыми кирпичиками для записи и чтения байтов в регистры чипа. Функция init_rfid выполняет "ритуал" инициализации, записывая в модуль серию значений из его технической документации. request посылает команду поиска карт, а anticollision считывает уникальный идентификатор (UID) обнаруженной карты и проверяет его целостность с помощью контрольной суммы (BCC).

Главный цикл программы

Этот финальный блок объединяет все функции в единую рабочую систему.

# === ГЛАВНЫЙ ЦИКЛ ===
try:
    init_rfid()
    antenna_on()
    show_message("RFID-сейф", "Ожидание карты...")
    close_lock()
    while True:
        if request():
            uid = anticollision()
            if uid:
                uid_str = [f"{b:02X}" for b in uid]
                print("UID:", uid_str)
                if uid_str == AUTHORIZED_UID:
                    show_message("Доступ разрешён", "Открытие замка")
                    open_lock()
                    time.sleep(5)
                    show_message("Замок открыт", "Закрыть замок?")
                    while True:
                        if request():
                            uid_check = anticollision()
                            if uid_check == uid:
                                close_lock()
                                show_message("Замок закрыт", "Ожидание...")
                                break
                            else:
                                show_message("❌ Ошибка", "Неверная карта")
                        time.sleep(0.1)
                else:
                    show_message("❌ Доступ запрещён", "Неверная карта")
                    time.sleep(3)
                    show_message("RFID-сейф", "Ожидание карты...")
        time.sleep(0.1)
except KeyboardInterrupt:
    print("\n[!] Завершение программы")
finally:
    spi.close()
    rst.close()
    show_message("Сейф отключён")
    close_lock()
    print("🛑 Программа завершена.")

Объяснение: Вся логика обернута в конструкцию try...finally. Блок try содержит основной бесконечный цикл, который реализует алгоритм: ждет карту (request), считывает ее UID (anticollision), сравнивает с разрешенным и, в зависимости от результата, открывает замок или сообщает об ошибке. Вложенный цикл while отвечает за процесс закрытия сейфа той же картой. Блок finally — это гарантия безопасного завершения. Он выполнится в любом случае, даже при прерывании по Ctrl+C, и обеспечит закрытие всех соединений и, что самое важное, блокировку замка.

2. Объектно-ориентированный подход (ООП) #

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

Классы-компоненты: OLEDDisplay и ServoLock

Сначала определим классы для управления периферийными устройствами: дисплеем и сервоприводом.

class OLEDDisplay:
    def __init__(self, address=0x3C, port=1, font_path="/usr/share/fonts/truetype/freefont/FreeSans.ttf", font_size=14):
        self.serial = i2c(port=port, address=address)
        self.oled = sh1106(self.serial)
        self.font = ImageFont.truetype(font_path, font_size)

    def show_message(self, line1, line2=""):
        image = Image.new("1", self.oled.size)
        draw = ImageDraw.Draw(image)
        draw.rectangle((0, 0, self.oled.width, self.oled.height), outline=0, fill=0)
        draw.text((0, 0), line1, font=self.font, fill=255)
        draw.text((0, 15), line2, font=self.font, fill=255)
        self.oled.display(image)

class ServoLock:
    def __init__(self, gpio_pin):
        self.gpio_pin = gpio_pin

    def _move_servo(self, position_us=1500, duration_ms=1000):
        # ... (здесь полный код функции move_servo из предыдущего примера) ...
        # Важно: GPIO(self.gpio_pin, "out") используется внутри этого метода
    
    def open(self):
        self._move_servo(2200, 1500)

    def close(self):
        self._move_servo(800, 1500)

Объяснение:

• OLEDDisplay: Этот класс инкапсулирует всю логику работы с дисплеем. В конструкторе (__init__) происходит вся необходимая инициализация. Метод show_message делает то же, что и одноименная функция в прошлом примере, но теперь он является частью объекта дисплея.
• ServoLock: Этот класс абстрагирует управление замком. Внутренняя логика генерации ШИМ-сигнала вынесена в "приватный" метод _move_servo. Наружу предоставляется простой и понятный интерфейс: lock.open() и lock.close(). Основной программе больше не нужно знать о микросекундах и длительности импульсов.

Класс-компонент: RFIDReader

Этот класс берет на себя всю сложную и низкоуровневую работу по взаимодействию с RFID-модулем.

class RFIDReader:
    def __init__(self, spi_device, rst_pin):
        self.spi = SPI(spi_device, 0, 1000000)
        self.rst = GPIO(rst_pin, "out")

    def write_reg(self, addr, val):
        # ... (код функции write_reg)

    def read_reg(self, addr):
        # ... (код функции read_reg)

    # ... и все остальные низкоуровневые функции RFID (set_bit_mask, reset, и т.д.)
    # становятся методами этого класса, использующими self.spi и self.rst
    
    def init(self):
        # ... (код функции init_rfid)

    def antenna_on(self):
        # ... (код функции antenna_on)

    def read_uid(self):
        """Высокоуровневый метод для чтения UID."""
        if self.request():
            return self.anticollision()
        return None

    def close(self):
        self.spi.close()
        self.rst.close()

Объяснение: Класс RFIDReader инкапсулирует все детали протокола MFRC522. Все глобальные функции из предыдущего примера (write_reg, init_rfid и т.д.) теперь являются методами этого класса. Мы также добавили удобный высокоуровневый метод read_uid, который сам выполняет request и anticollision, еще больше упрощая основной код. Метод close необходим для корректного освобождения ресурсов (SPI и GPIO).

Главный класс системы: RFIDSafeSystem

Этот класс является "оркестратором". Он создает экземпляры всех компонентов и реализует основную бизнес-логику сейфа.

class RFIDSafeSystem:
    def __init__(self, spi_device, rst_pin, servo_pin, oled_addr, authorized_uid):
        self.display = OLEDDisplay(address=oled_addr)
        self.lock = ServoLock(gpio_pin=servo_pin)
        self.rfid = RFIDReader(spi_device=spi_device, rst_pin=rst_pin)
        self.authorized_uid = authorized_uid

    def run(self):
        try:
            self.rfid.init()
            self.rfid.antenna_on()
            self.display.show_message("RFID-сейф", "Ожидание карты...")
            self.lock.close()
            
            while True:
                uid = self.rfid.read_uid()
                if uid:
                    uid_str = [f"{b:02X}" for b in uid]
                    print("UID:", uid_str)
                    
                    if uid_str == self.authorized_uid:
                        self.display.show_message("Доступ разрешён", "Открытие замка")
                        self.lock.open()
                        time.sleep(5)
                        self.display.show_message("Замок открыт", "Закрыть замок?")
                        
                        while True:
                            uid_check = self.rfid.read_uid()
                            if uid_check == uid:
                                self.lock.close()
                                self.display.show_message("Замок закрыт", "Ожидание...")
                                break
                            time.sleep(0.1)
                    else:
                        self.display.show_message("❌ Доступ запрещён")
                        time.sleep(3)
                        self.display.show_message("RFID-сейф", "Ожидание...")
                time.sleep(0.1)

        finally:
            self.rfid.close()
            self.display.show_message("Сейф отключён")
            self.lock.close()
            print("🛑 Программа завершена.")

Объяснение:

• Композиция: В конструкторе __init__ создаются и сохраняются экземпляры всех наших классов-компонентов. Это называется композицией — наш главный объект "состоит" из других объектов.
• Высокоуровневая логика: Метод run содержит тот же самый алгоритм, что и в функциональном подходе, но теперь он выглядит гораздо чище. Вместо вызова глобальных функций он обращается к методам своих компонентов: self.display.show_message(), self.lock.open(), self.rfid.read_uid(). Код описывает что происходит, а не как это происходит.
• Ресурсы: Блок finally теперь вызывает методы close() у соответствующих объектов, делегируя им ответственность за освобождение ресурсов.

Точка входа

Это финальная часть скрипта, которая запускает всю систему.

if __name__ == "__main__":
    # Создаем экземпляр всей системы
    safe = RFIDSafeSystem(
        spi_device=SPI_DEVICE,
        rst_pin=RST_PIN,
        servo_pin=SERVO_GPIO,
        oled_addr=OLED_ADDR,
        authorized_uid=AUTHORIZED_UID
    )
    # Запускаем основной цикл
    safe.run()

Объяснение: Этот блок выполняется только при запуске файла как основной программы. Он создает один-единственный объект RFIDSafeSystem, передавая ему все необходимые параметры, и вызывает его главный метод run(). Весь запуск сложной системы свелся к двум строчкам, что наглядно демонстрирует мощь и элегантность объектно-ориентированного подхода.

3. Подход с использованием библиотеки RepkaPi.GPIO.SYSFS #

Импортируются библиотеки для работы с периферией: SPI и GPIO для взаимодействия с RFID-модулем и сервоприводом, luma.oled для управления OLED-дисплеем по I2C, PIL для рисования текста и изображений на экране, а также стандартный модуль времени:

from periphery import SPI
import RepkaPi.GPIO as GPIO
from luma.core.interface.serial import i2c  
from luma.oled.device import sh1106 
from PIL import Image, ImageDraw, ImageFont 
import time  

Определяются основные параметры: путь к SPI-устройству для RFID, пины для сброса RFID и управления сервоприводом, адрес OLED-дисплея по I2C, а также UID авторизованной карты.

Эти значения используются для инициализации соответствующих устройств и проверки доступа.

SPI_DEVICE = "/dev/spidev0.0"  # Путь к устройству SPI
RST_PIN = 11  # Пин для сброса RFID модуля
SERVO_GPIO = 22  # Пин для управления сервоприводом (открытие/закрытие замка)
OLED_ADDR = 0x3C  # Адрес OLED-дисплея

AUTHORIZED_UID = ["C5", "2E", "B0", "05"]  # Замените на реальный UID вашей карты для авторизации

# --- инициализация GPIO ---
GPIO.setmode(GPIO.BOARD)
# Настраиваем пины один раз в начале
GPIO.setup(RST_PIN, GPIO.OUT, initial=GPIO.HIGH)
GPIO.setup(SERVO_GPIO, GPIO.OUT)

Инициализация OLED-дисплея: создаётся интерфейс I2C и объект устройства, а также загружается шрифт для вывода текста.

Это позволяет выводить сообщения пользователю о состоянии сейфа и результатах проверки карты.

serial = i2c(port=1, address=OLED_ADDR)  # Инициализация интерфейса I2C для OLED
oled = sh1106(serial)  # Создание объекта для управления OLED-дисплеем

font = ImageFont.truetype("/usr/share/fonts/truetype/freefont/FreeSans.ttf", 14)  # Устанавливаем шрифт для текста на экране

Функция show_message выводит две строки текста на OLED-дисплей.

Создаётся новое изображение, очищается экран, рисуются строки текста, и результат отображается на дисплее.

Это основной способ информирования пользователя о текущем состоянии устройства.

def show_message(line1, line2=""):
    image = Image.new("1", oled.size)  # Создаём новое изображение для экрана
    draw = ImageDraw.Draw(image)  # Инициализируем инструмент для рисования
    draw.rectangle((0, 0, oled.width, oled.height), outline=0, fill=0)  # Очищаем экран
    draw.text((0, 0), line1, font=font, fill=255)  # Рисуем первую строку текста
    draw.text((0, 15), line2, font=font, fill=255)  # Рисуем вторую строку текста
    oled.display(image)  # Отображаем изображение на OLED-дисплее

Функции для управления сервоприводом, который открывает и закрывает замок.

move_servo формирует PWM-сигнал на GPIO для управления положением сервопривода, а open_lock и close_lock задают конкретные позиции для открытия и закрытия замка.

Это позволяет реализовать механическую блокировку сейфа.

# === СЕРВОПРИВОД ===
def move_servo(position_us=1500, duration_ms=1000):
    pwm_frequency = 50
    period_s = 1.0 / pwm_frequency
    high_time_s = position_us / 1_000_000.0
    low_time_s = period_s - high_time_s
    
    if high_time_s < 0 or low_time_s < 0:
        return

    end_time = time.time() + (duration_ms / 1000.0)
    while time.time() < end_time:
        GPIO.output(SERVO_GPIO, GPIO.HIGH)
        time.sleep(high_time_s)
        GPIO.output(SERVO_GPIO, GPIO.LOW)
        time.sleep(low_time_s)

Инициализация SPI для работы с RFID-модулем :

spi = SPI(SPI_DEVICE, 0, 1000000)  # Инициализация SPI для работы с RFID

Набор функций для низкоуровневого взаимодействия с RFID-модулем: запись и чтение регистров, установка и очистка битовых масок, сброс и инициализация модуля, включение антенны, запрос карты, антикоррекция (anticollision) для получения UID.

Эти функции реализуют протокол обмена с RFID-ридером и позволяют получать UID приложенной карты:

def write_reg(addr, val):
    spi.transfer([(addr << 1) & 0x7E, val])

def read_reg(addr):
    return spi.transfer([((addr << 1) & 0x7E) | 0x80, 0])[1]

def set_bit_mask(reg, mask):
    val = read_reg(reg)
    write_reg(reg, val | mask)

def clear_bit_mask(reg, mask):
    val = read_reg(reg)
    write_reg(reg, val & (~mask))

def reset():
    rst.write(True)
    time.sleep(0.05)
    rst.write(False)
    time.sleep(0.05)
    rst.write(True)
    time.sleep(0.05)

def init_rfid():
    reset()  # Сброс модуля
    write_reg(0x01, 0x0F)  # Инициализация внутренних регистров
    time.sleep(0.05)
    write_reg(0x2A, 0x8D)
    write_reg(0x2B, 0x3E)
    write_reg(0x2D, 30)
    write_reg(0x2C, 0)
    write_reg(0x15, 0x40)
    write_reg(0x11, 0x3D)
    write_reg(0x01, 0x00)

def antenna_on():
    val = read_reg(0x14)
    if ~(val & 0x03):  # Проверка состояния антенны
        write_reg(0x14, val | 0x03)  # Включаем антенну

def request():
    write_reg(0x0D, 0x07)
    write_reg(0x01, 0x0C)
    write_reg(0x0A, 0x80)
    write_reg(0x09, 0x26)
    set_bit_mask(0x0D, 0x80)
    for _ in range(2000):
        if read_reg(0x04) & 0x30:
            break
    else:
        return False
    clear_bit_mask(0x0D, 0x80)
    if read_reg(0x06) & 0x1B:
        return False
    return [read_reg(0x09) for _ in range(read_reg(0x0A))]  # Чтение UID карты

def anticollision():
    write_reg(0x0D, 0x00)
    write_reg(0x01, 0x0C)
    write_reg(0x0A, 0x80)
    write_reg(0x09, 0x93)
    write_reg(0x09, 0x20)
    set_bit_mask(0x0D, 0x80)

    for _ in range(2000):
        if read_reg(0x04) & 0x30:
            break
    else:
        return False

    clear_bit_mask(0x0D, 0x80)

    if read_reg(0x06) & 0x1B:
        return False

    length = read_reg(0x0A)
    uid = [read_reg(0x09) for _ in range(length)]

    if not uid or len(uid) < 2:  # защита от пустого или короткого списка
        return False

    bcc = uid[-1]
    xor = 0
    for b in uid[:-1]:
        xor ^= b

    if xor != bcc:
        return False

Главный цикл программы: инициализация RFID и антенны, закрытие замка, вывод сообщения на дисплей.

В бесконечном цикле ожидается карта, читается её UID, сравнивается с авторизованным.

Если карта авторизована — замок открывается, затем ожидается повторное прикладывание той же карты для закрытия замка.

Если карта не авторизована — выводится сообщение об ошибке, замок не открывается.

Обработка прерывания (Ctrl+C) и завершения программы: освобождаются ресурсы, замок закрывается, выводится финальное сообщение.

# === ГЛАВНЫЙ ЦИКЛ ===
try:
    init_rfid()  # Инициализация RFID
    antenna_on()  # Включаем антенну
    show_message("RFID-сейф", "Ожидание карты...")  # Сообщение на экране
    close_lock()  # Закрываем замок

    while True:
        if request():  # Ожидаем карты
            uid = anticollision()  # Проверка на столкновение карт
            if uid:
                uid_str = [f"{b:02X}" for b in uid]  # Преобразование UID в строку
                print("UID:", uid_str)  # Выводим UID в консоль
                if uid_str == AUTHORIZED_UID:  # Проверка на авторизованный UID
                    show_message("Доступ разрешён", "Открытие замка")
                    print("✅ Доступ разрешён")
                    open_lock()  # Открываем замок
                    time.sleep(5)  # Задержка для открытия замка
                    show_message("Замок открыт", "Закрыть замок?")  # Сообщение о необходимости закрыть замок
                    while True:
                        if request():  # Проверка карты для закрытия
                            uid_check = anticollision()
                            if uid_check == uid:  # Если та же карта, закрываем замок
                                close_lock()
                                show_message("Замок закрыт", "Ожидание карты...")
                                break  # Выход из цикла ожидания
                            else:
                                show_message("❌ Ошибка", "Неверная карта")
                        time.sleep(0.1)
                else:
                    show_message("❌ Доступ запрещён", "Неизвестная карта")
                    print("❌ Доступ запрещён")
                    time.sleep(3)
                    show_message("RFID-сейф", "Ожидание карты...")
        time.sleep(0.1)

except KeyboardInterrupt:  # Обработка завершения программы
    print("\n[!] Завершение программы")

finally:
    # --- ИЗМЕНЕНИЕ: Правильная очистка ---
    spi.close()
    show_message("Сейф отключён")
    close_lock()
    # Вызываем одну функцию для очистки всех использованных пинов
    GPIO.cleanup()
    print("🛑 Программа завершена.")

---

Реализация на C #

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

1. Реализация с WiringRP #

Данная реализация использует модульный подход, где для каждого аппаратного компонента создан свой "драйвер" в виде пары файлов .h (заголовочный) и .c (реализация). Это профессиональная практика, которая делает код чистым, переиспользуемым и легким для отладки.

Структура проекта:

• main.c: Содержит основную логику приложения, инициализацию и главный цикл.
• mfrc522_rfid/: Модуль для низкоуровневого взаимодействия с RFID-чипом MFRC522 по SPI.
• oled_driver/: Драйвер для управления OLED-дисплеем по I2C, включая функции отрисовки и встроенный шрифт.
• servo_motor/: Модуль для управления сервоприводом с реализацией точного программного ШИМ.

Основной файл логики (main.c)

Этот файл является точкой входа и "мозгом" всей системы. Он инициализирует все модули и реализует логику конечного автомата.

// main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wiringrp/wiringRP.h>
#include "oled_driver.h"
#include "servo_motor.h"
#include "mfrc522_rfid.h"

// --- НАСТРОЙКА ---
const uint8_t AUTHORIZED_UID[4] = {0xC5, 0x2E, 0xB0, 0x05};
#define SERVO_PIN 22
// ... другие константы ...

typedef enum {
    STATE_LOCKED,
    STATE_ACCESS_DENIED,
    STATE_WAITING_TO_LOCK
} SafeState;

static Uid current_card_uid;

void show_message(const char* line1, const char* line2) { /* ... */ }

void setup() {
    setupWiringRP(WRP_MODE_PHYS);
    oled_init(OLED_I2C_BUS, OLED_ADDR);
    servo_init(SERVO_PIN);
    rfid_init(SPI_CHANNEL, RFID_RST_PIN, SPI_SPEED);
    
    show_message("RFID-Safe", "Waiting for card...");
    servo_lock();
}

void loop() {
    static SafeState state = STATE_LOCKED;
    Uid scanned_uid;

    if (rfid_is_card_present() && rfid_read_uid(&scanned_uid)) {
        // ... (логика конечного автомата внутри switch-case) ...
    }
}

ONDESTROY() {
    printf("\nЗавершение работы, блокировка сейфа...\n");
    servo_lock();
    // ... (очистка ресурсов) ...
    releaseWiringRP();
    exit(0);
}

MAIN_WIRINGRP();

Объяснение:

• Структура setup() и loop(): Библиотека WiringRP предоставляет макросы MAIN_WIRINGRP(), setup() и loop(), которые эмулируют привычную и удобную среду программирования Arduino. Код в setup() выполняется один раз при старте, а loop() — в бесконечном цикле.
• Конечный автомат: Логика сейфа реализована как конечный автомат с помощью перечисления SafeState. Система всегда находится в одном из состояний (STATE_LOCKED, STATE_WAITING_TO_LOCK и т.д.), а switch-case внутри loop() определяет, как реагировать на сканирование карты в зависимости от текущего состояния. Это делает логику предсказуемой и надежной.
• Безопасное завершение: Макрос ONDESTROY() регистрирует функцию, которая будет вызвана при завершении программы (например, по Ctrl+C). Это гарантирует, что сейф будет заблокирован, а все аппаратные ресурсы — корректно освобождены.

Модуль сервопривода (servo_motor.c)

Этот модуль отвечает за точное управление сервоприводом.

// servo_motor.c
#include "servo_motor.h"
#include <wiringrp/wiringRP.h>

#define SERVO_LOCKED_PULSE_US 800
#define SERVO_UNLOCKED_PULSE_US 2200
#define PWM_PERIOD_US 20000
#define PULSE_COUNT 75

static void send_pulses(int pulse_us) {
    long low_time_us = PWM_PERIOD_US - pulse_us;
    for (int i = 0; i < PULSE_COUNT; i++) {
        digitalWrite(servo_pin, HIGH);
        delayMicroseconds(pulse_us);
        digitalWrite(servo_pin, LOW);
        delayMicroseconds(low_time_us);
    }
}

void servo_lock(void) { send_pulses(SERVO_LOCKED_PULSE_US); }
void servo_unlock(void) { send_pulses(SERVO_UNLOCKED_PULSE_US); }

Объяснение: Модуль реализует очень точный программный ШИМ. Вместо использования неточных delay(), он использует delayMicroseconds() для генерации импульсов с точностью до микросекунды. Внутренняя функция send_pulses отправляет серию из 75 импульсов, чтобы гарантировать, что сервопривод успеет повернуться в нужное положение. Функции servo_lock и servo_unlock предоставляют простой интерфейс для основной программы.

Модуль OLED-дисплея (oled_driver.c)

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

// oled_driver.c
#include "oled_driver.h"
#include <wiringrp/wire.h>
#include <string.h>
#include "font.h" 

#define OLED_WIDTH 128
#define OLED_HEIGHT 64

static uint8_t buffer[OLED_HEIGHT / 8][OLED_WIDTH];

void oled_display(void) {
    // ... (код отправки буфера на дисплей по I2C) ...
}

static void oled_draw_pixel(int x, int y, int color) {
    // ... (код для установки одного пикселя в буфере) ...
}

void oled_draw_text(int x, int y, const char* text) {
    for (int i = 0; text[i] != '\0'; i++) {
        char c = text[i];
        const uint8_t* font_char = font5x7[c - 32];
        for (int col = 0; col < 5; col++) {
            for (int row = 0; row < 7; row++) {
                if ((font_char[col] >> row) & 1) {
                    oled_draw_pixel(x + i * 6 + col, y + row, 1);
                }
            }
        }
    }
}

Объяснение: Драйвер работает с видеобуфером — двухмерным массивом buffer, который представляет собой черно-белое изображение экрана в памяти. Функция oled_draw_text не рисует на экране напрямую. Вместо этого она берет по очереди каждый символ из текста, находит его побитовое представление в массиве font5x7 (из файла font.h) и с помощью функции oled_draw_pixel "зажигает" соответствующие пиксели в буфере. И только когда все изображение готово в памяти, функция oled_display отправляет весь буфер целиком на дисплей по шине I2C.

Модуль RFID (mfrc522_rfid.c)

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

// mfrc522_rfid.c
#include "mfrc522_rfid.h"
#include <wiringrp/spi.h>

// ... (определения регистров MFRC522) ...

static void write_reg(uint8_t reg, uint8_t val) { /* ... */ }
static uint8_t read_reg(uint8_t reg) { /* ... */ }

static bool to_card(uint8_t command, uint8_t* send, int send_len, uint8_t* back, int* back_len) {
    // ... (основная логика отправки команды и получения ответа от карты) ...
}

bool rfid_is_card_present() {
    // ... (вызывает to_card с командой PICC_REQIDL) ...
}

bool rfid_read_uid(Uid* uid) {
    // ... (вызывает to_card с командой PICC_ANTICOLL и проверяет CRC) ...
}

Объяснение: Модуль использует функции spiDataRW из WiringRP для прямого обмена данными с регистрами чипа MFRC522. Вся сложность протокола инкапсулирована во внутренней функции to_card, которая отправляет команду, управляет FIFO-буфером чипа и ожидает ответа. Внешнему миру (файлу main.c) предоставляется очень простой интерфейс из трех функций: rfid_init для настройки, rfid_is_card_present для проверки наличия карты и rfid_read_uid для ее чтения.

2. Гибридный подход (Python + WiringRP) #

Этот подход сочетает в себе лучшее из двух миров: простоту и гибкость Python для написания основной логики и высокую производительность и точность C для выполнения критичных ко времени операций.

Идея заключается в том, чтобы из Python-скрипта напрямую вызывать функции скомпилированной C-библиотеки libwiringrp.so. Это позволяет получить доступ к низкоуровневым возможностям, таким как микросекундные задержки, которые недоступны в стандартных Python-библиотеках, работающих через ядро Linux.

Загрузка C-библиотеки и определение функций

Первым шагом является загрузка общей библиотеки libwiringrp.so в Python-скрипт с помощью стандартного модуля ctypes.

import ctypes

# --- 1. Настройка библиотеки WiringRP через ctypes ---
try:
    wiringrp = ctypes.CDLL("libwiringrp.so")
except OSError:
    print("Ошибка: Не удалось найти 'libwiringrp.so'.")
    exit(1)

# Определение прототипов GPIO и временных функций
wiringrp.setupWiringRP.argtypes = [ctypes.c_int]
wiringrp.setupWiringRP.restype = ctypes.c_int

wiringrp.pinMode.argtypes = [ctypes.c_int, ctypes.c_int]
wiringrp.digitalWrite.argtypes = [ctypes.c_int, ctypes.c_int]
wiringrp.delayMicroseconds.argtypes = [ctypes.c_uint]

Объяснение:

• ctypes.CDLL("libwiringrp.so") загружает C-библиотеку в память и предоставляет объект wiringrp, через который можно обращаться к ее функциям.
• Определение прототипов (argtypes, restype): Это критически важный шаг. Мы явно указываем Python, какие типы данных (целые числа, указатели и т.д.) ожидает каждая C-функция и какой тип данных она возвращает. Это гарантирует корректную передачу данных между двумя языками.

Обновление низкоуровневых функций

Теперь мы можем переписать функции, требующие высокой точности, заменив вызовы Python-библиотек на вызовы функций из wiringrp.

# --- 3. Функции, обновленные для WiringRP ---

def move_servo(position_us=1500, duration_ms=1000):
    """Управляет сервоприводом с помощью точных задержек WiringRP."""
    pwm_frequency = 50
    period_us = 1_000_000 / pwm_frequency
    high_time_us = position_us
    low_time_us = int(period_us - high_time_us)

    end_time = time.time() + (duration_ms / 1000.0)
    while time.time() < end_time:
        wiringrp.digitalWrite(SERVO_GPIO, HIGH)
        wiringrp.delayMicroseconds(high_time_us)
        wiringrp.digitalWrite(SERVO_GPIO, LOW)
        wiringrp.delayMicroseconds(low_time_us)

def reset_rfid():
    """Сбрасывает RFID модуль, используя digitalWrite и delay из WiringRP."""
    wiringrp.digitalWrite(RST_PIN, HIGH)
    wiringrp.delay(50)
    wiringrp.digitalWrite(RST_PIN, LOW)
    wiringrp.delay(50)
    wiringrp.digitalWrite(RST_PIN, HIGH)
    wiringrp.delay(50)

Объяснение:

• move_servo: Эта функция теперь является сердцем гибридного подхода. Вместо time.sleep(), которая имеет низкую точность, мы используем wiringrp.delayMicroseconds(). Эта функция выполняется на уровне C и обеспечивает задержки с точностью до микросекунды, что позволяет генерировать идеально стабильный ШИМ-сигнал для сервопривода.
• reset_rfid: Функция сброса RFID-модуля также переписана для использования wiringrp.digitalWrite и wiringrp.delay, что обеспечивает более быструю и предсказуемую реакцию.

Основная логика и главный цикл

Важно отметить, что вся остальная часть программы остается неизменной. Мы по-прежнему используем Python-библиотеки periphery для SPI и luma.oled для дисплея, а также всю высокоуровневую логику на Python.

# === ГЛАВНЫЙ ЦИКЛ ===
try:
    # --- Инициализация WiringRP ---
    if wiringrp.setupWiringRP(WRP_MODE_PHYS) < 0:
        raise RuntimeError("Ошибка инициализации WiringRP.")

    # Настройка GPIO пинов через WiringRP
    wiringrp.pinMode(RST_PIN, OUTPUT)
    wiringrp.pinMode(SERVO_GPIO, OUTPUT)
    
    # ... (далее идет тот же самый главный цикл, что и в функциональном подходе) ...
    # ... он вызывает обновленные open_lock/close_lock и init_rfid ...

finally:
    # --- Очистка ресурсов ---
    spi.close()
    show_message("Сейф отключён")
    close_lock()
    
    # Отключаем пины и освобождаем библиотеку WiringRP
    wiringrp.pinMode(RST_PIN, DISABLE)
    wiringrp.pinMode(SERVO_GPIO, DISABLE)
    wiringrp.releaseWiringRP()
    
    print("🛑 Программа завершена.")

Объяснение:

• Инициализация: Перед входом в основной цикл мы инициализируем библиотеку wiringrp и настраиваем нужные GPIO-пины в режим OUTPUT.
• Основной цикл: Код внутри while True остается прежним, что демонстрирует главное преимущество подхода: мы не усложнили бизнес-логику. Мы лишь "подменили" низкоуровневую реализацию для move_servo и reset_rfid.
• Очистка: В блоке finally теперь, помимо закрытия SPI и блокировки замка, мы корректно освобождаем ресурсы, занятые библиотекой WiringRP, вызывая releaseWiringRP().

Вывод: Гибридный подход позволяет точечно оптимизировать производительность там, где это необходимо (например, для точного управления двигателями), сохраняя при этом удобство и скорость разработки на Python для остальной части проекта.

Сравнение производительности: RepkaPi.GPIO (SysFS) vs WiringRP #

В рамках наших проектов мы использовали два разных подхода для взаимодействия с GPIO-пинами:

1. Python с библиотекой RepkaPi.GPIO: Высокоуровневый подход, работающий через стандартный интерфейс ядра Linux SysFS.
2. C с библиотекой WiringRP: Низкоуровневый подход, работающий максимально близко к "железу" через прямой доступ к памяти.

Возникает логичный вопрос: насколько велика разница в производительности и когда какой подход следует выбирать? Для ответа на этот вопрос был проведен объективный тест — бенчмарк.

Методика тестирования #

Чтобы измерить чистую скорость работы с GPIO, была поставлена простая задача: переключать один и тот же GPIO-пин из высокого состояния (HIGH) в низкое (LOW) и обратно так быстро, как это возможно, в течение 5 секунд. Эта операция "включить-выключить" является фундаментальной для любого проекта, работающего с GPIO, и ее скорость напрямую отражает эффективность используемой библиотеки.

Были написаны два минималистичных скрипта, реализующих этот тест.

Код на C с WiringRP

// benchmark_c_counter.c
#include <wiringrp/wiringRP.h>
#include <stdio.h>
#include <time.h>

#define TEST_PIN 7
#define BENCHMARK_DURATION 5

int main(void) {
    unsigned long long counter = 0;
    time_t start_time = time(NULL);

    if (setupWiringRP(WRP_MODE_PHYS) < 0) return 1;
    
    pinMode(TEST_PIN, OUTPUT);
    
    while (1) {
        digitalWrite(TEST_PIN, HIGH);
        digitalWrite(TEST_PIN, LOW);
        counter++;
        
        if (time(NULL) - start_time >= BENCHMARK_DURATION) {
            break;
        }
    }
    
    printf("Операций в секунду: %llu ops/sec\n", counter / BENCHMARK_DURATION);
    return 0;
}

Код на Python с RepkaPi.GPIO

# benchmark_c_counter.py
import RepkaPi.GPIO as GPIO
import time

TEST_PIN = 7
BENCHMARK_DURATION = 5

GPIO.setmode(GPIO.BOARD)
GPIO.setup(TEST_PIN, GPIO.OUT)

counter = 0
start_time = time.time()

try:
    while True:
        GPIO.output(TEST_PIN, GPIO.HIGH)
        GPIO.output(TEST_PIN, GPIO.LOW)
        counter += 1
        
        if time.time() - start_time >= BENCHMARK_DURATION:
            break
finally:
    GPIO.cleanup()

print(f"Операций в секунду: {counter // BENCHMARK_DURATION} ops/sec")

Результаты #

После компиляции C-кода и запуска обоих скриптов на Repka Pi были получены следующие результаты:

Подход	Операций в секунду (ops/sec)
Python + RepkaPi.GPIO (SysFS)	~6,679
C + WiringRP (прямой доступ)	~484,638

Анализ результатов #

Как видно из таблицы, разница в производительности колоссальна: подход на C с использованием WiringRP оказался примерно в 72 раза быстрее, чем его аналог на Python. Эта разница обусловлена фундаментальными различиями в том, как эти библиотеки взаимодействуют с оборудованием.

• WiringRP (C):

  • Компилируемый язык: Код на C преобразуется в нативные машинные инструкции, которые выполняются процессором напрямую без посредников.
  • Прямой доступ к памяти (/dev/mem): WiringRP изменяет состояние GPIO-пина путем прямой записи нужных значений в физические адреса памяти, где расположены регистры управления GPIO. С точки зрения системы, это одна быстрая операция записи в память.

• RepkaPi.GPIO (Python):

  • Интерпретируемый язык: Код на Python выполняется через интерпретатор, который добавляет свои, хоть и небольшие, накладные расходы.
  • Интерфейс SysFS: Это ключевое отличие. Библиотека RepkaPi.GPIO работает через стандартный для Linux интерфейс SysFS. Для операционной системы GPIO-пины представлены в виде файлов в директории /sys/class/gpio/. Чтобы изменить состояние пина, библиотека выполняет целую последовательность действий:
    1. Отправляет системный вызов на открытие файла (например, /sys/class/gpio/gpio7/value).
    2. Отправляет системный вызов на запись в этот файл символа "1" или "0".
    3. Отправляет системный вызов на закрытие файла.

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

Выводы и рекомендации #

Означают ли эти результаты, что RepkaPi.GPIO — плохая библиотека? Однозначно нет. Выбор инструмента всегда зависит от задачи.

• Когда использовать Python и RepkaPi.GPIO? Почти всегда. Во всех проектах, которые мы рассмотрели (метеостанция, система полива, парктроник, RFID-сейф), основной цикл программы имеет задержку от сотен миллисекунд до нескольких секунд (time.sleep(1)). На фоне таких задержек разница в скорости выполнения GPIO.output() в несколько микросекунд абсолютно несущественна. Преимущества Python — скорость разработки, простота отладки, читаемость кода и огромное количество готовых библиотек — многократно перевешивают проигрыш в "чистой" производительности GPIO.

• Когда использовать C и WiringRP? WiringRP и C становятся незаменимы, когда требуется работа в реальном времени или генерация высокочастотных сигналов. Например:

  • Программная реализация протоколов связи (например, "bit-banging" I2C или SPI).
  • Управление устройствами, требующими очень точных и коротких импульсов, недостижимых с помощью time.sleep().
  • Приложения, где критически важна минимальная и предсказуемая задержка реакции на событие.

Итог: Для подавляющего большинства образовательных и хобби-проектов удобство и скорость разработки на Python с RepkaPi.GPIO являются предпочтительным выбором. К мощи и производительности C и WiringRP следует обращаться тогда, когда вы точно знаете, что ваш проект упирается в пределы скорости или точности, которые может предоставить Python.

Практическая значимость проекта

Проект "RFID-сейф" представляет собой практическое решение для обеспечения безопасности хранения личных вещей и ценностей с использованием технологий RFID. Такая система может найти широкое применение в различных сферах, включая личные сейфы, защищенные шкафы, системы контроля доступа на предприятиях и в частных домах. Применение RFID-технологии позволяет создать удобный и надежный способ авторизации с минимальными усилиями для пользователя (просто поднесите метку или карту). Это повышает уровень безопасности, исключая необходимость запоминания паролей или использования физических ключей, которые могут быть потеряны или украдены.

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

Расширение проекта

1. Интеграция с мобильными приложениями: Проект можно расширить за счет создания мобильного приложения, которое будет взаимодействовать с RFID-сейфом через Bluetooth или Wi-Fi. Пользователь мог бы удаленно управлять замком сейфа или получать уведомления о попытках несанкционированного доступа.

2. Многофакторная аутентификация: Для повышения уровня безопасности можно добавить возможность комбинированного использования RFID с PIN-кодом или биометрической аутентификацией (например, считывание отпечатков пальцев).

3. Использование облачных технологий: Внедрение облачного хранения данных позволит управлять доступом и контролировать состояние сейфа через интернет. Это обеспечит возможность удаленной настройки и мониторинга.

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

5. Модуль расширенной безопасности: Можно добавить дополнительные датчики, такие как датчики движения или вибрации, для защиты от попыток вскрытия сейфа.

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

Видеообзор проекта

Для более детального ознакомления с проектом, вы можете посмотреть видеообзор на платформе Rutube:

Пример использования с Python

Проект полностью реализован на языке Python. Код для работы с RFID-сейфом можно найти в репозитории на платформе Gitflic.