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

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

Для подключения нам потребуется “Распиновка портов на 40 pin разъёме на Repka Pi 4“, см. рисунок ниже:Поскольку расширительная плата GPIO полностью повторяет конфигурацию распиновки, можно применить те же таблицы и схемы, которые использовались ранее для устройств.

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

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

12. Подключим FC-28 к макетной плате согласно таблице 2:

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

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

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

14. Подключим  реле модуль 3V к макетной плате согласно таблице 4:

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

15. Подключаем помпу к макетной плате и реле согласно таблице 5.

Внимание! Для подключения помпы используйте дополнительный источник питания, такой как лабораторный, аккумуляторный или батарейный блок, а не подключение через Repka Pi 4.

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

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

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

16. Выполним подключение дисплея к макетной плате согласно таблице 6:

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

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

Импортируются необходимые библиотеки для работы с I2C, GPIO, временем, LCD-дисплеем и др:

import RepkaPi.GPIO as GPIO
from periphery import I2C
from smbus2 import SMBus
from datetime import datetime
import time
import errno
from RPLCD.i2c import CharLCD

Определяются адреса устройств на шине I2C, номер шины, пин реле и порог влажности:

ADS1115_ADDR = 0x48  # Адрес АЦП ADS1115 (датчик влажности)
DS3231_ADDR = 0x68   # Адрес RTC модуля DS3231 (часы реального времени)
I2C_BUS_NUM = 1      # Номер шины I2C (обычно 1 на Repka PI)
RELAY_GPIO = 11     # GPIO пин для управления реле (насосом)
MOISTURE_THRESHOLD = 20  # Порог влажности для включения полива (в процентах)

Инициализация I2C для работы с АЦП:

i2c_adc = I2C("/dev/i2c-1")

Функция для чтения влажности почвы с датчика через АЦП ADS1115. Возвращает влажность в процентах:

def read_soil_moisture():
    """
    Считывает значение влажности почвы с датчика через АЦП ADS1115.
    Возвращает значение влажности в процентах от 0 до 100.
    При ошибках повторяет попытку до 5 раз.
    """
    config = 0xC183  # Конфигурация для ADS1115 (одноканальный режим и др.)
    attempts = 5     # Максимум 5 попыток чтения
    
    for attempt in range(attempts):
        try:
            # Отправляем конфигурацию в регистр конфигурации АЦП (0x01)
            i2c_adc.transfer(ADS1115_ADDR, [I2C.Message([0x01, (config >> 8) & 0xFF, config & 0xFF])])
            time.sleep(0.01)  # Краткая пауза для установки конфигурации

            # Запрашиваем данные из регистра конверсии (0x00)
            i2c_adc.transfer(ADS1115_ADDR, [I2C.Message([0x00])])
            read_msg = I2C.Message([0x00, 0x00], read=True)  # Подготовка к чтению 2 байт
            i2c_adc.transfer(ADS1115_ADDR, [read_msg])

            # Объединяем два байта в одно 16-битное число
            raw = (read_msg.data[0] << 8) | read_msg.data[1]
            # Преобразуем из формата с дополнительным кодом в знаковое число
            if raw & 0x8000:
                raw -= 1 << 16

            # Преобразуем сырое значение в проценты влажности
            # Чем выше raw, тем меньше влажность (инверсия)
            moisture = 100 - int((raw + 32768) / 65535 * 100)

            # Ограничиваем результат в диапазоне 0-100%
            return max(0, min(100, moisture))

        except IOError as e:
            # Если шина занята (EAGAIN, EBUSY) или прервалось чтение (EINTR), повторяем
            if e.errno in (errno.EAGAIN, errno.EBUSY, errno.EINTR):
                print(f"Попытка {attempt+1}/{attempts}: шина занята, повтор через 50 мс")
                time.sleep(0.05)
                continue
            else:
                # При других ошибках выбрасываем исключение дальше
                raise
    # Если не удалось считать после всех попыток, выбрасываем ошибку
    raise IOError("Не удалось считать данные с ADC после нескольких попыток")

Функция для преобразования BCD-значения в десятичное:

def bcd2dec(bcd):
    return (bcd >> 4) * 10 + (bcd & 0x0F)

Функция для чтения текущего времени с RTC DS3231:

def read_time(bus):
    """
    Считывает текущее время с RTC DS3231 через I2C.
    Возвращает объект datetime с текущей датой и временем.
    """
    # Считываем 7 байт, начиная с регистра 0x00 (секунды, минуты, часы, день, дата, месяц, год)
    data = bus.read_i2c_block_data(DS3231_ADDR, 0x00, 7)
    # Преобразуем BCD значения в обычные числа и создаем datetime
    return datetime(2000 + bcd2dec(data[6]),  # Год (от 2000)
                    bcd2dec(data[5]),        # Месяц
                    bcd2dec(data[4]),        # День
                    bcd2dec(data[2]),        # Часы
                    bcd2dec(data[1]),        # Минуты
                    bcd2dec(data[0]))        # Секунды

Функции для включения и выключения насоса:

def water_on():
    """
    Включает насос, устанавливая сигнал LOW (0) на пин реле.
    """
    GPIO.output(RELAY_GPIO, GPIO.LOW)  # LOW = включено

def water_off():
    """
    Выключает насос, устанавливая сигнал HIGH (1) на пин реле.
    """
    GPIO.output(RELAY_GPIO, GPIO.HIGH)   # HIGH = выключено

Инициализация LCD-дисплея 1602 по I2C:

lcd = CharLCD('PCF8574', 0x27, cols=16, rows=2)

Функция для отображения времени и влажности на дисплее:

def display_status(time_str, moisture):
    """
    Отображает текущие время и влажность на дисплее.
    Первая строка — время, вторая — влажность.
    """
    lcd.clear()  # Очищаем дисплей перед выводом
    lcd.write_string(f'Время: {time_str}')  # Первая строка — время
    lcd.cursor_pos = (1, 0)                 # Переходим на вторую строку, первый символ
    lcd.write_string(f'Влажн.: {moisture}%')  # Вторая строка — влажность

Основная функция программы: инициализация GPIO, выбор режима, основной цикл, логика автополива, полива по времени и по интервалу:

def main():

    # --- Инициализация GPIO ---
    # Устанавливаем режим нумерации пинов по их физическому расположению.
    GPIO.setmode(GPIO.BOARD)
    # Настраиваем пин реле как ВЫХОД и сразу выключаем насос (HIGH).
    GPIO.setup(RELAY_GPIO, GPIO.OUT, initial=GPIO.HIGH)

    # Меню выбора режима работы
    print("Выберите режим:")
    # ... остальной код функции

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

Класс SoilMoistureSensor инкапсулирует работу с датчиком влажности почвы через АЦП ADS1115 по I2C.

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

Метод read реализует чтение влажности: отправляет конфигурацию, инициирует измерение, затем читает результат, преобразует его в проценты.

Встроена обработка ошибок: если шина занята или произошёл сбой, делается несколько попыток чтения с задержкой.

Метод close освобождает ресурсы, закрывая соединение с I2C-устройством.

class SoilMoistureSensor:
    def __init__(self, i2c_path, address):
        self.i2c = I2C(i2c_path)
        self.address = address

    def read(self):
        config = 0xC183
        attempts = 5
        for attempt in range(attempts):
            try:
                self.i2c.transfer(self.address, [I2C.Message([0x01, (config >> 8) & 0xFF, config & 0xFF])])
                time.sleep(0.01)
                self.i2c.transfer(self.address, [I2C.Message([0x00])])
                read_msg = I2C.Message([0x00, 0x00], read=True)
                self.i2c.transfer(self.address, [read_msg])
                raw = (read_msg.data[0] << 8) | read_msg.data[1]
                if raw & 0x8000:
                    raw -= 1 << 16
                moisture = 100 - int((raw + 32768) / 65535 * 100)
                return max(0, min(100, moisture))
            except IOError as e:
                if e.errno in (errno.EAGAIN, errno.EBUSY, errno.EINTR):
                    print(f"Попытка {attempt+1}/{attempts}: шина занята, повтор через 50 мс")
                    time.sleep(0.05)
                    continue
                else:
                    raise
        raise IOError("Не удалось считать данные с ADC после нескольких попыток")

    def close(self):
        self.i2c.close()

Класс RTCClock предназначен для работы с модулем реального времени DS3231 по I2C.

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

Метод bcd2dec преобразует значения из формата BCD (используется в DS3231) в обычные десятичные числа.

Метод read_time читает 7 байт из RTC, преобразует их в значения даты и времени, и возвращает объект datetime.

Это позволяет легко интегрировать текущее время в логику автополива и отображать его на дисплее.

class RTCClock:
    def __init__(self, bus_num, address):
        self.bus_num = bus_num
        self.address = address

    def bcd2dec(self, bcd):
        return (bcd >> 4) * 10 + (bcd & 0x0F)

    def read_time(self, bus):
        data = bus.read_i2c_block_data(self.address, 0x00, 7)
        return datetime(2000 + self.bcd2dec(data[6]),
                        self.bcd2dec(data[5]),
                        self.bcd2dec(data[4]),
                        self.bcd2dec(data[2]),
                        self.bcd2dec(data[1]),
                        self.bcd2dec(data[0]))

Класс Relay управляет исполнительным устройством — реле, которое включает и выключает насос.

В конструкторе инициализируется GPIO-пин в режиме вывода, что позволяет подавать сигналы на реле.

Метод on включает насос, подавая низкий уровень (LOW), а метод off выключает насос, подавая высокий уровень (HIGH).

Такое управление характерно для большинства реле, где LOW — это включение.

Метод close освобождает ресурсы, закрывая GPIO-пин.

    
class Relay:
    def __init__(self, gpio_pin):
        
        self.pin = gpio_pin
        

    def on(self):
        GPIO.output(self.pin, GPIO.LOW)

    def off(self):
        GPIO.output(self.pin, GPIO.HIGH)

    def close(self):
        
        pass

Класс LCDDisplay инкапсулирует работу с LCD-дисплеем 1602 по I2C.

В конструкторе создаётся объект дисплея с нужным адресом и размером (16x2 символа).

Метод display_status очищает дисплей и выводит на первой строке текущее время, а на второй — влажность почвы.

Метод clear просто очищает дисплей, а stop_message выводит сообщение о завершении работы системы.

Это позволяет централизованно управлять отображением информации для пользователя.

class LCDDisplay:
    def __init__(self, address=0x27, cols=16, rows=2):
        self.lcd = CharLCD('PCF8574', address, cols=cols, rows=rows)

    def display_status(self, time_str, moisture):
        self.lcd.clear()
        self.lcd.write_string(f'Время: {time_str}')
        self.lcd.cursor_pos = (1, 0)
        self.lcd.write_string(f'Влажн.: {moisture}%')

    def clear(self):
        self.lcd.clear()

    def stop_message(self):
        self.lcd.clear()
        self.lcd.write_string("Система остановлена")

Главный класс AutomaticIrrigationSystem объединяет все компоненты системы: датчик, часы, реле и дисплей.

В конструкторе создаются объекты всех классов-компонентов, а также задаётся порог влажности для автополива.

Метод run реализует основной цикл работы: выбор режима, чтение данных, принятие решений о поливе, обновление дисплея.

В каждом режиме реализована своя логика: автополив по влажности, полив по таймеру или по расписанию.

В блоке finally гарантируется корректное завершение работы: выключение насоса, освобождение ресурсов, вывод сообщения на дисплей.

class AutomaticIrrigationSystem:
    def __init__(self):
        self.sensor = SoilMoistureSensor("/dev/i2c-1", 0x48)
        self.rtc = RTCClock(1, 0x68)
        self.relay = Relay(11) # <-- Исправлен пин
        self.lcd = LCDDisplay()
        self.moisture_threshold = 20
        
        # --- Инициализация GPIO  ---
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(self.relay.pin, GPIO.OUT, initial=GPIO.HIGH)

    def run(self):
        print("Выберите режим:")
        print("1 — Автополив по влажности")
        print("2 — Полив каждые N секунд")
        print("3 — Полив по времени (часы RTC)")
        mode = input(">>> ")

        interval = 60
        if mode == "2":
            interval = int(input("Введите интервал в секундах: "))
        schedule_time = input("Введите время для полива (часы:минуты, напр. 07:30): ") if mode == "3" else ""

        with SMBus(1) as bus:
            try:
                while True:
                    now = self.rtc.read_time(bus)
                    try:
                        moist = self.sensor.read()
                    except IOError as e:
                        print(f"Ошибка чтения влажности: {e}")
                        moist = -1

                    time_str = now.strftime('%H:%M:%S')
                    print(f"[{time_str}] Влажность: {moist}%")
                    self.lcd.display_status(time_str, moist if moist >= 0 else 0)

                    if mode == "1":
                        if moist >= 0 and moist < self.moisture_threshold:
                            print("Слишком сухо — включаю насос")
                            self.relay.on()
                            time.sleep(3)
                            self.relay.off()
                        time.sleep(1)

                    elif mode == "2":
                        print(f"Полив каждые {interval} сек.")
                        self.relay.on()
                        time.sleep(3)
                        self.relay.off()
                        for _ in range(interval):
                            now = self.rtc.read_time(bus)
                            try:
                                moist = self.sensor.read()
                            except IOError as e:
                                print(f"Ошибка чтения влажности: {e}")
                                moist = -1
                            self.lcd.display_status(now.strftime('%H:%M:%S'), moist if moist >= 0 else 0)
                            time.sleep(1)

                    elif mode == "3":
                        target_hour, target_min = map(int, schedule_time.split(":"))
                        if now.hour == target_hour and now.minute == target_min:
                            print("Время пришло — включаю полив!")
                            self.relay.on()
                            time.sleep(3)
                            self.relay.off()
                            print("Ждем минуту, чтобы не включать насос несколько раз")
                            time.sleep(60)
                        else:
                            time.sleep(1)
            except KeyboardInterrupt:
                print("Выход...")
        finally:
            self.relay.off()
            self.sensor.close()
            self.lcd.stop_message()
            GPIO.cleanup()

main - точка входа в программу.

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

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

Такой подход — стандарт для Python-программ, чтобы избежать непреднамеренного выполнения кода при импорте.

Вся логика инкапсулирована в классе, что облегчает тестирование и расширение системы.

if __name__ == "__main__":
    system = AutomaticIrrigationSystem()
    system.run()

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

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

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

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

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

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

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

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

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

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

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

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

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