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

Для более бюджетной реализации проекта можно обойтись без активного охлаждения, используя 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 В:

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

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

Проект реализован на языке python. Для того чтобы понять логику работы программы рассмотрите блок схему ниже:

Импортируются библиотеки для работы с периферией: 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("🛑 Программа завершена.")

Пример кода выше с использованием ООП

OLEDDisplay класс для управления OLED-дисплеем.

Инкапсулирует инициализацию, вывод текста и очистку экрана.

Позволяет централизованно управлять визуальной обратной связью для пользователя.

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)

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

Реализует методы для открытия и закрытия замка с помощью PWM-сигнала на GPIO.

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

class ServoLock:
    def __init__(self, gpio_pin):
        """
        Инициализирует сервопривод.
        
        :param gpio_pin: Номер пина в режиме GPIO.BOARD.
        """
        self.gpio_pin = gpio_pin
        GPIO.setup(self.gpio_pin, GPIO.OUT, initial=GPIO.LOW)

    def move_servo(self, 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
        
        try:
            end_time = time.time() + (duration_ms / 1000)
            while time.time() < end_time:
                GPIO.output(self.gpio_pin, GPIO.HIGH)
                time.sleep(high_time)
                GPIO.output(self.gpio_pin, GPIO.LOW)
                time.sleep(low_time)
        finally:
            # Убеждаемся, что пин остался в низком состоянии
            GPIO.output(self.gpio_pin, GPIO.LOW)

Класс RFIDReader для работы с RFID-модулем через SPI и GPIO.

Инкапсулирует все низкоуровневые операции: чтение/запись регистров, инициализацию, работу с антенной, чтение UID карты.

Позволяет легко расширять или модифицировать работу с 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):
        self.spi.transfer([(addr << 1) & 0x7E, val])

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

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

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

    def reset(self):
        GPIO.output(RST_PIN, GPIO.HIGH)
        time.sleep(0.05)
        GPIO.output(RST_PIN, GPIO.LOW)
        time.sleep(0.05)
        GPIO.output(RST_PIN, GPIO.HIGH)
        time.sleep(0.05)

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

    def antenna_on(self):
        val = self.read_reg(0x14)
        if ~(val & 0x03):
            self.write_reg(0x14, val | 0x03)

    def request(self):
        self.write_reg(0x0D, 0x07)
        self.write_reg(0x01, 0x0C)
        self.write_reg(0x0A, 0x80)
        self.write_reg(0x09, 0x26)
        self.set_bit_mask(0x0D, 0x80)
        for _ in range(2000):
            if self.read_reg(0x04) & 0x30:
                break
        else:
            return False
        self.clear_bit_mask(0x0D, 0x80)
        if self.read_reg(0x06) & 0x1B:
            return False
        return [self.read_reg(0x09) for _ in range(self.read_reg(0x0A))]

    def anticollision(self):
        self.write_reg(0x0D, 0x00)
        self.write_reg(0x01, 0x0C)
        self.write_reg(0x0A, 0x80)
        self.write_reg(0x09, 0x93)
        self.write_reg(0x09, 0x20)
        self.set_bit_mask(0x0D, 0x80)
        for _ in range(2000):
            if self.read_reg(0x04) & 0x30:
                break
        else:
            return False
        self.clear_bit_mask(0x0D, 0x80)
        if self.read_reg(0x06) & 0x1B:
            return False
        length = self.read_reg(0x0A)
        uid = [self.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
        return uid[:-1]

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

Главный RFIDSafeSystem класс системы RFID-сейфа.

Инкапсулирует все компоненты: дисплей, замок, RFID-ридер, а также логику авторизации и управления замком.

В методе run реализован основной цикл работы устройства.

class RFIDSafeSystem:
    def __init__(self, spi_device, rst_pin, servo_pin, oled_addr, authorized_uid):
        self.display = OLEDDisplay(address=oled_addr)
        self.lock = ServoLock(servo_pin)
        self.rfid = RFIDReader(spi_device, 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:
                if self.rfid.request():
                    uid = self.rfid.anticollision()
                    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("Доступ разрешён", "Открытие замка")
                            print("✅ Доступ разрешён")
                            self.lock.open()
                            time.sleep(5)
                            self.display.show_message("Замок открыт", "Закрыть замок?")
                            while True:
                                if self.rfid.request():
                                    uid_check = self.rfid.anticollision()
                                    if uid_check and [f"{b:02X}" for b in uid_check] == uid_str:
                                        self.lock.close()
                                        self.display.show_message("Замок закрыт", "Ожидание карты...")
                                        break
                                    else:
                                        self.display.show_message("❌ Ошибка", "Неверная карта")
                                time.sleep(0.1)
                        else:
                            self.display.show_message("❌ Доступ запрещён", "Неизвестная карта")
                            print("❌ Доступ запрещён")
                            time.sleep(3)
                            self.display.show_message("RFID-сейф", "Ожидание карты...")
                time.sleep(0.1)
        except KeyboardInterrupt:
            print("\n[!] Завершение программы")
        finally:
            spi.close()
            show_message("Сейф отключён")
            close_lock()
            # Вызываем одну функцию для очистки всех использованных пинов
            GPIO.cleanup()
            print("🛑 Программа завершена.")

Точка входа в программу.

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

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

if __name__ == "__main__":
    SPI_DEVICE = "/dev/spidev0.0"
    RST_PIN = 11
    SERVO_GPIO = 22
    OLED_ADDR = 0x3C
    AUTHORIZED_UID = ["C5", "2E", "B0", "05"]  # Замените на реальный UID вашей карты

    safe = RFIDSafeSystem(
        spi_device=SPI_DEVICE,
        rst_pin=RST_PIN,
        servo_pin=SERVO_GPIO,
        oled_addr=OLED_ADDR,
        authorized_uid=AUTHORIZED_UID
    )
    safe.run()

Преимущества ООП-подхода:

1. Модульность и повторное использование кода

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

Это позволяет легко переиспользовать эти классы в других проектах или расширять функциональность без переписывания кода.

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

2. Упрощение поддержки и масштабирования

Код, разделённый на классы с чётко определённой ответственностью, проще читать, тестировать и отлаживать.

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

Это особенно важно для сложных или развивающихся проектов, где часто появляются новые требования.

3. Инкапсуляция и защита данных

ООП позволяет скрыть внутренние детали реализации (например, работу с I2C или обработку ошибок) внутри класса.

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

Это снижает вероятность ошибок, связанных с неправильным использованием компонентов, и делает интерфейс системы более понятным и безопасным.