Представляю вам образовательный проект — “RFID-сейф”, разработанный в рамках учебно-методического комплекса на базе одноплатного компьютера Repka PI 4.
Проект представляет собой систему безопасности для сейфа, использующую технологию RFID для авторизации доступа. Система автоматически открывает замок, управляемый сервоприводом, при условии, что карта с правильным UID (уникальным идентификатором) успешно проходит проверку. Также система закрывает замок, если карту поднести повторно, обеспечивая надежную защиту от несанкционированного доступа.
Проект будет собираться с использованием “Учебно-методический комплекс REPKA”. Схему сборки можно найти в разделе "Примеры готовых проектов" учебного пособия УМК “REPKA”.
Также все необходимые материалы и схемы подключения доступны в репозитории на платформе Gitflic.
Компоненты проекта
- Сервопривод MG90S используется для управления механизмом замка сейфа, см. рисунок 1.
2. Модуль RFID RC-522 используется для считывания данных с RFID меток или карт, см. рисунок 2. Каждая карта или метка имеет уникальный UID (идентификатор), который модуль может считать при поднесении.
3. Дисплей OLED 0.96" I2C используется для отображения информации о состоянии системы безопасности.
Ссылки на модули приведены в таблице ниже.
Компонент | Ссылка на приобретение |
---|---|
Монтажная/макетная плата | Ссылка |
Шлейф | Ссылка |
Переходник с шлейфа на макетную плату | Ссылка |
Соединительные провода | |
Сервопривод MG90S | Ссылка |
RFID RC-522 | Ссылка |
Дисплей OLED 0.96" I2C | Ссылка |
Подготовительный этап
1. Подключим дополнительное питание 5V к макетной плате:
2. После чего выведем дополнительное питание на макетную плату:
3. Подключим переходник с шлейфа на макетную плату:
4. Соединим шлейф с переходником для подключения к макетной плате и Repka Pi 4:
5. Итоговый результат должен выглядеть таким образом:
Сборка проекта
Во время сборки проекта будем регулярно обращаться к электрической принципиальной схеме и монтажной схеме, представленными в учебном пособии (см. рисунки 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 В:
А. Подключение с использованием лабораторного блока питания:
Б. Подключение с использованием аккумуляторного блока питания:
Разбор кода проекта.
Проект реализован на языке 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 или обработку ошибок) внутри класса.
Внешний код работает только с публичными методами, не заботясь о низкоуровневых деталях.
Это снижает вероятность ошибок, связанных с неправильным использованием компонентов, и делает интерфейс системы более понятным и безопасным.
Практическая значимость проекта
Проект "RFID-сейф" представляет собой практическое решение для обеспечения безопасности хранения личных вещей и ценностей с использованием технологий RFID. Такая система может найти широкое применение в различных сферах, включая личные сейфы, защищенные шкафы, системы контроля доступа на предприятиях и в частных домах. Применение RFID-технологии позволяет создать удобный и надежный способ авторизации с минимальными усилиями для пользователя (просто поднесите метку или карту). Это повышает уровень безопасности, исключая необходимость запоминания паролей или использования физических ключей, которые могут быть потеряны или украдены.
Проект также позволяет продемонстрировать реальное применение технологий микроконтроллеров, радиочастотной идентификации и управления механическими устройствами, что является ценным образовательным инструментом. Он может служить основой для создания более сложных систем безопасности и интеграции с другими технологиями, такими как биометрия или сети умного дома.
Расширение проекта
-
Интеграция с мобильными приложениями: Проект можно расширить за счет создания мобильного приложения, которое будет взаимодействовать с RFID-сейфом через Bluetooth или Wi-Fi. Пользователь мог бы удаленно управлять замком сейфа или получать уведомления о попытках несанкционированного доступа.
-
Многофакторная аутентификация: Для повышения уровня безопасности можно добавить возможность комбинированного использования RFID с PIN-кодом или биометрической аутентификацией (например, считывание отпечатков пальцев).
-
Использование облачных технологий: Внедрение облачного хранения данных позволит управлять доступом и контролировать состояние сейфа через интернет. Это обеспечит возможность удаленной настройки и мониторинга.
-
Интеграция с системами умного дома: Система может быть связана с другими устройствами умного дома, такими как камеры наблюдения, сигнализация или системы освещения, для создания более комплексной системы безопасности.
-
Модуль расширенной безопасности: Можно добавить дополнительные датчики, такие как датчики движения или вибрации, для защиты от попыток вскрытия сейфа.
-
Автоматическое отслеживание доступа: Проект можно дополнить функцией ведения журнала доступа, записывая информацию о времени и идентификаторе карты каждого открытия сейфа. Эти данные могут храниться в локальной базе данных или в облаке.
Видеообзор проекта
Для более детального ознакомления с проектом, вы можете посмотреть видеообзор на платформе Rutube:
Пример использования с Python
Проект полностью реализован на языке Python. Код для работы с RFID-сейфом можно найти в репозитории на платформе Gitflic.