Проект “Сигнализация” на базе одноплатного компьютера Repka PI 4.

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

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

7. Выполним подключение зуммера к макетной плате согласно таблице 1:

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

8. Подключение датчика движения AM312. Выполним подключение к макетной плате согласно таблице 2:

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

9.1. Подключение матрицы (MAX7219). Выполним подключение к макетной плате согласно таблице 3.

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

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

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

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

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

Импортируются необходимые библиотеки: для работы с GPIO, временем, потоками, SPI-интерфейсом, LED-матрицей и шрифтами:

from periphery import GPIO
import time
import threading
from luma.core.interface.serial import spi, noop
from luma.led_matrix.device import max7219
from luma.core.render import canvas
from PIL import ImageFont

Инициализация пина для датчика движения (PIR-сенсор) как вход:

PIN1 = 362  # GPIO17
msi = GPIO(PIN1, "in")

Инициализация пина для зуммера как выход:

BEEP_PIN = 111  # Укажите номер пина для зуммера
beep = GPIO(BEEP_PIN, "out")

Настройка SPI-интерфейса и инициализация LED-матрицы max7219, установка яркости:

serial = spi(port=0, device=0, gpio=noop())
device = max7219(serial, cascaded=1, block_orientation=0, rotate=0)
device.contrast(16)  # Яркость матрицы

Функция alarm_signal для генерации звука на зуммере с заданной частотой и длительностью:

def alarm_signal():
    for _ in range(10):
        beep_tone(1000, 0.1)  # Высокий сигнал
        time.sleep(0.05)
        beep_tone(2000, 0.1)  # Высокий сигнал
        time.sleep(0.05)
    time.sleep(0.5)

Функция blink_matrix мигает всей матрицей 5 раз:

def blink_matrix():
    # Мигающий текст на матрице
    for _ in range(5):  # Мигание 5 раз
        with canvas(device) as draw:
            draw.rectangle(device.bounding_box, outline="black", fill="black")  # Очищаем экран
        time.sleep(0.2)
        with canvas(device) as draw:
            draw.rectangle(device.bounding_box, outline="white", fill="white")  # Заполняем экран белым
        time.sleep(0.2)

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

def show_on_matrix(text):
    font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 8)
    bbox = font.getbbox(text)
    w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
    offset_y = bbox[1]
    x = (device.width  - w) // 2
    y = (device.height - h) // 2 - offset_y

    with canvas(device) as draw:
        draw.text((x, y), text, font=font, fill="white")

Функция motion_detected_action запускает тревожный сигнал и мигание матрицы параллельно в отдельных потоках, затем ждёт их завершения:

def motion_detected_action():
    # Запускаем тревожный сигнал и мигание матрицы одновременно
    alarm_thread = threading.Thread(target=alarm_signal)
    matrix_thread = threading.Thread(target=blink_matrix)
    
    alarm_thread.start()
    matrix_thread.start()
    
    alarm_thread.join()  # Ожидаем завершения тревожного сигнала
    matrix_thread.join()  # Ожидаем завершения мигания матрицы

Основной цикл программы:

• Ждёт срабатывания датчика движения.

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

• Если движения не было 5 секунд — выключает зуммер, очищает матрицу, сбрасывает флаг.

• Каждые 0.1 секунды проверяет состояние датчика.

• При завершении работы освобождает ресурсы (закрывает пины).

try:
    print("Ожидание срабатывания датчика. Нажми Ctrl+C для выхода.")
    last_motion_time = time.time()  # Время последнего движения
    motion_detected = False

    while True:
        if msi.read():  # Если движение обнаружено
            motion_detected = True
            last_motion_time = time.time()  # Обновляем время последнего движения
            print("Датчик сработал!")
            motion_detected_action()  # Запуск действия при движении
        else:
            if motion_detected and time.time() - last_motion_time > 5:  # Если движение не было 5 секунд
                print("Движение не обнаружено 5 секунд, затухаем...")
                beep.write(False)  # Выключаем зуммер
                with canvas(device) as draw:  # Очищаем экран матрицы
                    draw.rectangle(device.bounding_box, outline="black", fill="black")
                motion_detected = False  # Сбрасываем флаг

        time.sleep(0.1)  # Пауза перед следующим циклом

except KeyboardInterrupt:
    print("Завершение программы")

finally:
    beep.close()  # Закрываем зуммер

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

Объявляется основной класс SignalFolderDemo. Внутри класса определяются константы для номеров пинов датчика движения и зуммера:

class SignalFolderDemo:
    # Константы для пинов
    PIN1 = 362  # GPIO17 для датчика движения
    BEEP_PIN = 111  # Пин для зуммера

Конструктор класса. Здесь инициализируются все устройства: датчик движения, зуммер, SPI-интерфейс и LED-матрица. Также задаются переменные состояния для отслеживания времени последнего движения и флага обнаружения движения:

    def __init__(self):
        # Инициализация датчика движения
        self.msi = GPIO(self.PIN1, "in")
        # Инициализация зуммера
        self.beep = GPIO(self.BEEP_PIN, "out")
        # Инициализация SPI интерфейса и матрицы
        self.serial = spi(port=0, device=0, gpio=noop())
        self.device = max7219(self.serial, cascaded=1, block_orientation=0, rotate=0)
        self.device.contrast(16)  # Яркость матрицы
        # Состояния
        self.last_motion_time = time.time()  # Время последнего движения
        self.motion_detected = False

Метод alarm_signal для генерации звука на зуммере с заданной частотой и длительностью. Включает и выключает зуммер с нужным интервалом:

    # Тревожный сигнал (чередование двух тонов)
    def alarm_signal(self):
        for _ in range(10):
            self.beep_tone(1000, 0.1)
            time.sleep(0.05)
            self.beep_tone(2000, 0.1)
            time.sleep(0.05)
        time.sleep(0.5)

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

    # Отображение текста на матрице
    def show_on_matrix(self, text):
        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 8)
        bbox = font.getbbox(text)
        w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
        offset_y = bbox[1]
        x = (self.device.width  - w) // 2
        y = (self.device.height - h) // 2 - offset_y
        with canvas(self.device) as draw:
            draw.text((x, y), text, font=font, fill="white")

Метод blink_matrix для мигания всей матрицей 5 раз:

 # Мигающий дисплей
    def blink_matrix(self):
        for _ in range(5):
            with canvas(self.device) as draw:
                draw.rectangle(self.device.bounding_box, outline="black", fill="black")
            time.sleep(0.2)
            with canvas(self.device) as draw:
                draw.rectangle(self.device.bounding_box, outline="white", fill="white")
            time.sleep(0.2)

Метод motion_detected_action запускает тревожный сигнал и мигание матрицы параллельно в отдельных потоках, затем ждёт их завершения:

    # Параллельный запуск тревоги и мигания
    def motion_detected_action(self):
        alarm_thread = threading.Thread(target=self.alarm_signal)
        matrix_thread = threading.Thread(target=self.blink_matrix)
        alarm_thread.start()
        matrix_thread.start()
        alarm_thread.join()
        matrix_thread.join()

Основной цикл программы:

• Ждёт срабатывания датчика движения.

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

• Если движения не было 5 секунд — выключает зуммер, очищает матрицу, сбрасывает флаг.

• Каждые 0.1 секунды проверяет состояние датчика.

• При завершении работы освобождает ресурсы (закрывает пины).

     # Основной цикл работы
      def run(self):
          try:
              print("Ожидание срабатывания датчика. Нажми Ctrl+C для выхода.")
              self.last_motion_time = time.time()
              self.motion_detected = False
              while True:
                  if self.msi.read():  # Если движение обнаружено
                      self.motion_detected = True
                      self.last_motion_time = time.time()
                      print("Датчик сработал!")
                      self.motion_detected_action()
                  else:
                      if self.motion_detected and time.time() - self.last_motion_time > 5:
                          print("Движение не обнаружено 5 секунд, затухаем...")
                          self.beep.write(False)
                          with canvas(self.device) as draw:
                              draw.rectangle(self.device.bounding_box, outline="black", fill="black")
                          self.motion_detected = False
                  time.sleep(0.1)
          except KeyboardInterrupt:
              print("Завершение программы")
          finally:
              self.beep.close()
              self.msi.close()
  

  Точка входа: создаётся экземпляр класса и запускается основной цикл:

if __name__ == "__main__":
    demo = SignalFolderDemo()
    demo.run()

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

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

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

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

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

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

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

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

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

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

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

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

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