Проект “Охота на светлячка” на базе одноплатного компьютера Repka PI 4.

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

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

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

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

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

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

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

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

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

14. Подключение  трехосевого гироскопа и акселерометра (GY-521; MPU-6050).

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

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

А. Лабораторный блока питания:

Б. Аккумуляторный блока питания:

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

Импортируются библиотеки для работы с оборудованием: гироскоп, дисплей, кнопка, светодиоды, зуммер:

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

Инициализация OLED-дисплея:

serial = i2c(port=1, address=0x3C)
device = sh1106(serial)
font = ImageFont.load_default()

Настройка пина кнопки: сначала как выход (сбросить уровень), затем как вход:

BTN_PIN = 203
temp_gpio = GPIO(BTN_PIN, "out")
temp_gpio.write(False)
temp_gpio.close()
btn = GPIO(BTN_PIN, "in")

Управление RGB-светодиодом:

R = GPIO(111, "out")
G = GPIO(112, "out")
B = GPIO(113, "out")
def led(r=False, g=False, b=False): ...
def led_off(): ...

Управление зуммером: генерация звука нужной частоты и длительности:

BEEP_PIN = 362
beep = GPIO(BEEP_PIN, "out")
def beep_tone(freq=1000, duration=0.2): ...

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

Пример: is_tilted_to('up') вернет True, если устройство наклонено вверх.

sensor = mpu6050(0x68)
def is_tilted_to(direction, threshold=5): ...

Вывод текста и стрелок на OLED-дисплей:

def display_text(line1="", line2=""): ...
def draw_arrow(direction): ...

Основной игровой цикл: 10 раундов, в каждом случайное направление, проверка наклона и нажатия кнопки:

За правильное действие — +1 балл, за ошибку или промедление — -1 балл.

def play_game():
    score = 0
    display_text("Firefly Hunt", "Get Ready!")
    time.sleep(2)
    for round_num in range(1, 11):
        ...
        required_direction = random.choice(["up", "down", "left", "right"])
        draw_arrow(required_direction)
        ...
        while time.time() - firefly_time < 1.5:
            if not btn.read():
                btn_pressed = True
                if is_tilted_to(required_direction):
                    press_ok = True
                else:
                    press_ok = False
                break
            time.sleep(0.01)
        ...
        if btn_pressed and press_ok:
            led(g=True)
            beep_tone(2000, 0.2)
            score += 1
            display_text("Success!", f"Score: {score}")
        else:
            led(r=True)
            beep_tone(1000, 0.2)
            score -= 1
            ...
        time.sleep(1)
        led_off()
    display_text("Game Over", f"Final: {score}")
    time.sleep(5)
    device.clear()

Запуск игры, обработка выхода по Ctrl+C, корректное закрытие ресурсов:

try:
    play_game()
except KeyboardInterrupt:
    print("Выход...")
finally:
    btn.close()
    R.close()
    G.close()
    B.close()
    beep.close()

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

Определяем класс FireflyGame, который инкапсулирует всю логику игры и работу с устройствами:

class FireflyGame:

В конструкторе класса def _init_ инициализируем все устройства:

    def __init__(self):
        self.device = sh1106(i2c(port=1, address=0x3C))
        self.font = ImageFont.load_default()
        self.btn = self._init_button(203)
        self.leds = { 'R': GPIO(111, "out"), 'G': GPIO(112, "out"), 'B': GPIO(113, "out") }
        self.beep = GPIO(362, "out")
        self.sensor = mpu6050(0x68)

Вспомогательный метод _init_button для корректной инициализации кнопки:

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

    def _init_button(self, pin):
        temp_gpio = GPIO(pin, "out")
        temp_gpio.write(False)
        temp_gpio.close()
        return GPIO(pin, "in")

Метод def led для управления цветом RGB-светодиода:

Можно включать любой цвет, передав True для нужного канала.

     def led(self, r=False, g=False, b=False):
        self.leds['R'].write(r)
        self.leds['G'].write(g)
        self.leds['B'].write(b)

Метод led_off для выключения всех каналов светодиода:

    def led_off(self):
        self.led()

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

    def beep_tone(self, freq=1000, duration=0.2):
        period = 1 / freq
        half = period / 2
        end = time.time() + duration
        while time.time() < end:
            self.beep.write(True)
            time.sleep(half)
            self.beep.write(False)
            time.sleep(half)

Метод is_tilted_to для проверки, наклонено ли устройство в нужном направлении:

Использует данные акселерометра.

    def is_tilted_to(self, direction, threshold=5):
        accel = self.sensor.get_accel_data()
        x, y = accel['x'], accel['y']
        if direction == "up":
            return y > threshold
        elif direction == "down":
            return y < -threshold
        elif direction == "left":
            return x < -threshold
        elif direction == "right":
            return x > threshold
        return False

Метод display_text для вывода двух строк текста на OLED-дисплей:

    def display_text(self, line1="", line2=""):
        from PIL import ImageDraw, Image
        image = Image.new("1", self.device.size)
        draw = ImageDraw.Draw(image)
        draw.rectangle((0, 0, self.device.width, self.device.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.device.display(image)

Метод draw_arrow для отображения стрелки нужного направления и подсказки на дисплее:

    def draw_arrow(self, direction):
        from PIL import ImageDraw, Image
        image = Image.new("1", self.device.size)
        draw = ImageDraw.Draw(image)
        draw.rectangle((0, 0, self.device.width, self.device.height), outline=0, fill=0)
        cx, cy = self.device.width // 2, self.device.height // 2
        if direction == "up":
            draw.polygon([(cx, cy - 10), (cx - 5, cy), (cx + 5, cy)], fill=255)
        elif direction == "down":
            draw.polygon([(cx, cy + 10), (cx - 5, cy), (cx + 5, cy)], fill=255)
        elif direction == "left":
            draw.polygon([(cx - 10, cy), (cx, cy - 5), (cx, cy + 5)], fill=255)
        elif direction == "right":
            draw.polygon([(cx + 10, cy), (cx, cy - 5), (cx, cy + 5)], fill=255)
        draw.text((0, 0), "* Firefly! *", font=self.font, fill=255)
        draw.text((0, 15), "Tilt & Press", font=self.font, fill=255)
        self.device.display(image)

Основной игровой цикл play:

• 10 раундов

• В каждом раунде случайное направление

• Ожидание наклона и нажатия кнопки

• Подсчет очков, обратная связь через светодиод, зуммер и дисплей

    def play(self):
        score = 0
        self.display_text("Firefly Hunt", "Get Ready!")
        time.sleep(2)
        for round_num in range(1, 11):
            self.display_text(f"Round {round_num}", "Prepare...")
            time.sleep(random.uniform(3, 6))
            required_direction = random.choice(["up", "down", "left", "right"])
            self.draw_arrow(required_direction)
            firefly_time = time.time()
            btn_pressed = False
            press_ok = False
            while time.time() - firefly_time < 1.5:
                if not self.btn.read():
                    btn_pressed = True
                    if self.is_tilted_to(required_direction):
                        press_ok = True
                    else:
                        press_ok = False
                    break
                time.sleep(0.01)
            if btn_pressed and press_ok:
                self.led(g=True)
                self.beep_tone(2000, 0.2)
                score += 1
                self.display_text("Success!", f"Score: {score}")
            else:
                self.led(r=True)
                self.beep_tone(1000, 0.2)
                score -= 1
                if not btn_pressed:
                    self.display_text("Too Slow!", f"Score: {score}")
                elif not self.is_tilted_to(required_direction):
                    self.display_text("Wrong Tilt!", f"Score: {score}")
                else:
                    self.display_text("Missed!", f"Score: {score}")
            time.sleep(1)
            self.led_off()
        self.display_text("Game Over", f"Final: {score}")
        time.sleep(5)
        self.device.clear()

Метод cleanup для корректного освобождения всех ресурсов (закрытие пинов):

    def cleanup(self):
        self.btn.close()
        for led in self.leds.values():
            led.close()
        self.beep.close()

Точка входа: создаём объект игры, запускаем игровой цикл, при завершении освобождаем ресурсы.

if __name__ == "__main__":
    game = FireflyGame()
    try:
        game.play()
    except KeyboardInterrupt:
        print("Выход...")
    finally:
        game.cleanup()

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

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

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

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

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

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

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

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

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

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

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

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

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