Проект “Детектор звука” на базе одноплатного компьютера Repka PI 4.

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

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

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

8. Подключим АЦП (ADS1115) к макетной плате согласно таблице 1:

9. Подключаем микрофон к к макетной плате согласно таблице 2:

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

10. Выполним подключение OLED дисплея согласно таблице 3:

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

11. Подключим RGB LED к макетной плате согласно таблице 4:

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

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

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

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

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

Код импортирует библиотеки для работы с I2C, GPIO, OLED-дисплеем, изображениями, шрифтами и временем.

Далее инициализируются:

• I2C-шина для связи с АЦП ADS1115 (микрофон)

• GPIO-пины для управления RGB-светодиодом

• OLED-дисплей (через I2C)

• Объекты для рисования на экране и шрифт для текста

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

# Создаем объект для работы с шиной I2C (указан порт "/dev/i2c-1" для Repka PI)
i2c_bus = I2C("/dev/i2c-1")

# Адрес устройства ADS1115 на шине I2C (по умолчанию 0x48)
ADS1115_ADDR = 0x48

# Номера GPIO пинов для подключения RGB светодиода
PIN_R = 354  # Красный (GPIO17)
PIN_G = 355  # Зеленый (GPIO27)
PIN_B = 359  # Синий (GPIO22)

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

# Создаем новое изображение (черно-белое), которое будет отображаться на дисплее
image = Image.new("1", device.size)  # "1" — это черно-белое изображение
draw = ImageDraw.Draw(image)  # Объект для рисования на изображении
# Загружаем шрифт, который будет использоваться для текста на дисплее
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 8)

# Инициализация пинов GPIO для RGB светодиода
R = GPIO(PIN_R, "out")  # Красный пин, настроен как выход
G = GPIO(PIN_G, "out")  # Зеленый пин, настроен как выход
B = GPIO(PIN_B, "out")  # Синий пин, настроен как выход

Функция read_mic()

Считывает аналоговый сигнал с микрофона через ADS1115 по I2C:

• Отправляет конфигурацию на ADS1115 для начала измерения

• Читает два байта данных с регистра результата

• Преобразует их в 16-битное целое число (с учетом знака)

• Возвращает уровень громкости

# Функция для чтения данных с микрофона, подключенного к ADS1115 через I2C
def read_mic():
    # Конфигурация для ADS1115
    config = 0xC183  # 16-битное значение для настройки входа AIN0 и других параметров
    # Отправляем конфигурацию на ADS1115 для начала измерения
    i2c_bus.transfer(ADS1115_ADDR, [I2C.Message([0x01, (config >> 8) & 0xFF, config & 0xFF])])

    # Читаем данные с регистра 0x00 (результаты измерений)
    i2c_bus.transfer(ADS1115_ADDR, [I2C.Message([0x00])])
    read = I2C.Message([0x00, 0x00], read=True)  # Читаем два байта данных
    i2c_bus.transfer(ADS1115_ADDR, [read])

    # Преобразуем два байта в одно 16-битное число
    raw = (read.data[0] << 8) | read.data[1]

    # Если число отрицательное (16-битный формат со знаком), преобразуем его
    if raw & 0x8000:
        raw -= 1 << 16

    return raw  # Возвращаем значение громкости

Функция control_rgb_based_on_volume(volume)

В зависимости от уровня громкости включает определённый цвет на RGB-светодиоде:

• Красный — громко (volume > 9000)

• Зелёный — средне (volume > 8000)

• Синий — тише (volume > 4000)

• Всё выключено — очень тихо

# Функция для управления RGB светодиодом в зависимости от громкости звука
def control_rgb_based_on_volume(volume):
    # Включаем красный цвет, если громкость слишком высокая
    if volume > 9000:
        R.write(True)
        G.write(False)
        B.write(False)
    # Включаем зеленый цвет для среднего уровня громкости
    elif volume > 8000:
        R.write(False)
        G.write(True)
        B.write(False)
    # Включаем синий цвет для низкой громкости
    elif volume > 4000:
        R.write(False)
        G.write(False)
        B.write(True)
    else:
        # Если громкость ниже порога, выключаем светодиод
        R.write(False)
        G.write(False)
        B.write(False)

Функция display_volume_on_oled(volume)

Очищает изображение, рисует текст с текущим значением громкости и выводит его на OLED-дисплей:

# Функция для отображения громкости на OLED дисплее
def display_volume_on_oled(volume):
    # Очищаем дисплей (черный фон)
    draw.rectangle((0, 0, device.width, device.height), outline=0, fill=0)
    # Рисуем текст на дисплее, который будет показывать громкость
    draw.text((0, 10), f"Громкость: {volume}", font=font, fill=255)  # Текст белым цветом
    # Отображаем изображение на дисплее
    device.display(image)

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

В бесконечном цикле:

• Считывает уровень громкости с микрофона

• Управляет цветом RGB-светодиода в зависимости от громкости

Отображает значение громкости на OLED-дисплее

# Основной цикл программы
try:
    while True:
        # Чтение значения с микрофона
        val = read_mic()
        
        # Управляем цветом RGB светодиода в зависимости от громкости
        control_rgb_based_on_volume(val)
        
        # Отображаем громкость на OLED дисплее
        display_volume_on_oled(val)

Завершение работы (обработка KeyboardInterrupt)

При завершении программы (например, по Ctrl+C):

• Очищает дисплей

• Закрывает GPIO-пины светодиода

• Закрывает интерфейс I2C

# Обработка исключения при выходе из программы (например, через Ctrl+C)
except KeyboardInterrupt:
    # Очистка дисплея перед выходом
    device.clear()

    # Закрытие GPIO пинов
    R.close()
    G.close()
    B.close()
    # Закрытие интерфейса I2C
    i2c_bus.close()

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

Класс MicrophoneADC

Отвечает за работу с микрофоном через АЦП ADS1115 по I2C.

• init_: инициализирует I2C-шину и адрес АЦП.

• read: отправляет конфигурацию на ADS1115, читает 16-битное значение с микрофона, возвращает уровень громкости.

• close: закрывает I2C-шину.

# Класс для работы с микрофоном через ADS1115
class MicrophoneADC:
    def __init__(self, i2c_dev="/dev/i2c-1", addr=0x48):
        self.i2c_bus = I2C(i2c_dev)
        self.addr = addr

    def read(self):
        # Конфигурация для ADS1115 (канал AIN0)
        config = 0xC183
        # Отправляем конфигурацию
        self.i2c_bus.transfer(self.addr, [I2C.Message([0x01, (config >> 8) & 0xFF, config & 0xFF])])
        # Читаем данные
        self.i2c_bus.transfer(self.addr, [I2C.Message([0x00])])
        read = I2C.Message([0x00, 0x00], read=True)
        self.i2c_bus.transfer(self.addr, [read])
        raw = (read.data[0] << 8) | read.data[1]
        if raw & 0x8000:
            raw -= 1 << 16
        return raw

    def close(self):
        self.i2c_bus.close()

Класс RGBLed

Инкапсулирует управление RGB-светодиодом через три GPIO-пина.

• init_: инициализирует пины для красного, зелёного и синего каналов.

• set_color: включает/выключает каждый цвет по отдельности.

• control_by_volume: включает определённый цвет в зависимости от уровня громкости (красный — громко, зелёный — средне, синий — тише, всё выключено — очень тихо).

• close: освобождает все пины.

# Класс для управления RGB светодиодом
class RGBLed:
    def __init__(self, pin_r=354, pin_g=355, pin_b=359):
        self.R = GPIO(pin_r, "out")
        self.G = GPIO(pin_g, "out")
        self.B = GPIO(pin_b, "out")

    def set_color(self, r=False, g=False, b=False):
        self.R.write(r)
        self.G.write(g)
        self.B.write(b)

    def control_by_volume(self, volume):
        # Управление цветом в зависимости от громкости
        if volume > 9000:
            self.set_color(r=True, g=False, b=False)    # Красный
        elif volume > 8000:
            self.set_color(r=False, g=True, b=False)    # Зеленый
        elif volume > 4000:
            self.set_color(r=False, g=False, b=True)    # Синий
        else:
            self.set_color(r=False, g=False, b=False)   # Выключено

    def close(self):
        self.R.close()
        self.G.close()
        self.B.close()

Класс OLEDDisplay

Отвечает за вывод информации на OLED-дисплей.

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

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

• clear: очищает дисплей.

# Класс для работы с OLED дисплеем
class OLEDDisplay:
    def __init__(self, port=1, address=0x3C):
        self.serial = i2c(port=port, address=address)
        self.device = sh1106(self.serial)
        self.image = Image.new("1", self.device.size)
        self.draw = ImageDraw.Draw(self.image)
        # Используем стандартный шрифт
        self.font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 8)

    def display_volume(self, volume):
        # Очищаем экран
        self.draw.rectangle((0, 0, self.device.width, self.device.height), outline=0, fill=0)
        # Рисуем текст
        self.draw.text((0, 10), f"Громкость: {volume}", font=self.font, fill=255)
        self.device.display(self.image)

    def clear(self):
        self.device.clear()

Класс VolumeDetectorApp

Главный управляющий класс приложения.

• init_: создаёт объекты для микрофона, светодиода и дисплея.

• run: основной цикл работы.

В цикле:

• Считывает громкость с микрофона.

• Управляет цветом RGB-светодиода в зависимости от громкости.

• Отображает громкость на OLED-дисплее.

При завершении (Ctrl+C) очищает дисплей и освобождает ресурсы.

# Главный класс приложения
class VolumeDetectorApp:
    def __init__(self):
        # Инициализация всех устройств
        self.mic = MicrophoneADC()
        self.led = RGBLed()
        self.display = OLEDDisplay()

    def run(self):
        try:
            while True:
                # Считываем громкость с микрофона
                volume = self.mic.read()
                # Управляем светодиодом
                self.led.control_by_volume(volume)
                # Отображаем громкость на дисплее
                self.display.display_volume(volume)
        except KeyboardInterrupt:
            # При завершении очищаем дисплей и освобождаем ресурсы
            self.display.clear()
            self.led.close()
            self.mic.close()

Точка входа

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

# Точка входа
if __name__ == "__main__":
    # Запускаем приложение
    app = VolumeDetectorApp()
    app.run()

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

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

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

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

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

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

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

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

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

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

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

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

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