repkatech
repkatech
524 просмотров0 комментариев

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

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

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

Проект будет собираться с использованием “Учебно-методический комплекс REPKA”. Схему сборки можно найти в разделе "Примеры готовых проектов" учебного пособия УМК “REPKA”.

Также все необходимые материалы и схемы подключения доступны в репозитории на платформе Gitflic.

Компоненты проекта

  1. Потребуется аналогово-цифровой преобразователь (далее АЦП) модели ADS1115, см. рисунок 1.

2. Датчик влажности почвы (FC-28) для мониторинга уровня влаги в почве, см. рисунок 2.

3. Часы (DS3231) требуются для реализации функционала полив по времени или каждые N секунд, см. рисунок 3.

4. Дисплей 1602 I2C для отображения показаний с датчика влажности почвы и времени.

5. Помпа 5 вольт для полива растения.

6. Реле модуль 3v для запуска помпы.

Вы можете приобрести все необходимые компоненты отдельно от "Учебно-методический комплекс REPKA". Ссылки на модули приведены в таблице ниже.

Компонент Ссылка на приобретение
Монтажная/макетная плата Ссылка
Шлейф Ссылка
Переходник с шлейфа на макетную плату Ссылка
Соединительные провода

Провода соединительные м-п

Провода соединительные п-п

Провода соединительные п-п

АЦП (ADS1115) Ссылка
Часы (DS3231) Ссылка
Дисплей 1602 I2C Ссылка
Помпа 5 вольт Ссылка
Реле модуль 3v Ссылка
Датчик влажности почвы (FC-28) Ссылка

Подготовительный этап

1. Подключим дополнительное питание 5V к макетной плате:

2. После чего выведем дополнительное питание на макетную плату:

3. Подключим переходник с шлейфа на макетную плату:

4. Соединим шлейф с переходником для подключения к макетной плате и Repka Pi 4:

5. Итоговый результат должен выглядеть таким образом:

Сборка проекта

Во время сборки проекта будем регулярно обращаться к электрической принципиальной схеме и монтажной схеме, представленными в учебном пособии (см. рисунки 7 и 8). Эти схемы будут служить основным ориентиром на всех этапах подключения компонентов, обеспечивая точность и правильность сборки устройства.

Для разработки кода будет использоваться текстовый редактор Geany, котороый входит в состав стандартного ПО Репка ОС.

Электрическая принципиальная схема #

Монтажная схема

1. Подключение АЦП (ADS1115).

Как видно из рисунков 7 и 8 АЦП подключается через интерфейс I2C и питается от 5V.

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

Макетная плата АЦП (ADS1115)
5V V
GND G
SCL1 SCL
SDA1 SDA

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

1.2.  Результат подключения будет выглядеть следующим образом, см. рисунок 9:

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

2. Подключение датчик влажности почвы (FC-28).

Как видно из рисунков 7 и 8, плата датчика FC-28 подключается к АЦП через пин A0 и получает питание от 5V.

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

Макетная плата FC-28 АЦП (ADS1115)
5V VCC
GND GND
A0 A0

Таблица 2. Подключение платы датчика влажности почвы (FC-28) к макетной плате.

2.2.  Результат подключения будет выглядеть следующим образом, см. рисунок 10:

2.3. После чего подключаем сам датчик к плате согласно схемам выше, результат на рисунке 11. Тут все просто плюс к плюсу, минус к минусу.

3. Выполним проверку подключения устройств АЦП и датчика влажности. Для этого будем использовать python скрипт из репозитория repka-pi_iot-examples.

3.1. Клонируем репозиторий:

git clone git@gitflic.ru:repka_pi/repka-pi_iot-examples.git

3.2. Переходим в репозиторий:

cd repka-pi_iot-examples/

3.3. Выполним установку зависимостей.

3.3.1. Если хотите установить зависимости только для датчика влажности, выполните:

make setup-fc-28

3.3.2. Если хотите установить зависимости для всех датчиков и проектов, выполните:

make setup-all

3.4. Запускаем скрипт для проверки работоспособности прибора:

make fc-28

3.5. Если на этапе 3.4 возникает ошибка, необходимо внести изменения в Python-скрипт, расположенный по пути devices/sensors/FC-28_example/py, корректируя номер – i2c = I2C("/dev/i2c-1") и адрес шины – ADS1115_ADDR. В случае отсутствия ошибок, данный шаг можно пропустить.

Адрес ADS1115 на шине I2C

ADS1115_ADDR = 0x48

# Подключение к I2C

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

3.6. Из рисунка 12 видим, что скрипт успешно выполнился, и данные о влажности выводятся в консоль.

4. Подключение часов (DS3231).

Как видно из рисунков 7 и 8 часы подключаются через интерфейс I2C и питаются от 5V.

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

Макетная плата DS3231
5V VCC
GND GND
SDA1 SDA
SCL1 SCL

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

При использовании модуля часов форм-фактора, как у меня, подключение может быть затруднено из-за отсутствия полноценных подписей на разъёмах. Для удобства прилагаю изображение, которое поможет вам правильно осуществить подключение.

5. Аналогично пункту 4 выполним проверку подключения датчика.

5.1. Установите зависимости для часов, если ранее не устанавливали все зависимости.

make setup-ds3231

5.2. После выполним python скрипт, расположенный по пути: /devices/input-output/ds3231_example, используя команду:

make ds3231

5.3. После успешного выполнения скрипта в консоли должна появится информация о времени, см. рисунок 14.

6. Подключение реле модуля 3V.

Как видно из рисунков 7 и 8, реле подключается к 5V и управляется через GPIO.

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

Макетная плата Реле
3V VCC
GND GND
GPIO17 IN
GND NO

Таблица 4. Подключение реле модуля 3V к макетной плате.

6.2.  Результат подключения будет выглядеть следующим образом, см. рисунок 15:

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

7. Подключение помпы 5V.

Как видно из рисунков 7 и 8, помпа подключается плюсом к 5V макетной платы, а минусом к реле.

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

Макетная плата Помпа Реле
5V VCC
GND GND

Таблица 5. Подключение помпы к макетной плате.

7.2. Результат подключения будет выглядеть следующим образом, см. рисунок 16:

8. Выполним проверку подключения аналогично пункту 3.

8.1. Установите зависимости для помпы, если ранее не устанавливали все зависимости.

make setup-pump

8.2. После выполним python скрипт, расположенный по пути: /devices/executive/pump_example/py, используя команду:

make pump

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

9. Подключение ЖК дисплея (1602 I2C).

Как видно из рисунков 7 и 8, дисплей подключается по интерфейсу I2c и питается от 5V.

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

Макетная плата

1602 I2C

5V

VCC

GND

GND

SCL1

SCL

SDA1

SDA

Таблица 6. Подключение ЖК дисплея (1602 I2C) к макетной плате.

9.2. Результат подключения будет выглядеть следующим образом, см. рисунок 17:

10. Выполним проверку подключения аналогично пункту 3.

10.1. Установим зависимости для ЖК дисплея (1602 I2C), выполнив:

make setup-display-1602-i2c

10.2. Выполните команду:

make display-1602-i2c

10.3. Как видно из рисунка 18 дисплей успешно подключен.

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

Для более бюджетной реализации проекта можно обойтись без активного охлаждения, используя 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 или обработку ошибок) внутри класса.

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

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

Запуск проекта

Теперь, когда все компоненты подключены, можно запустить проект "Автоматическая системы полива". Для этого в репозитории repka-pi_iot-examples выполняем команду:

make automatic-irrigation-system

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

Практическая значимость проекта

Проект "Автоматизированная система полива" представляет собой практическое решение для автоматизации процесса полива растений, что значительно упрощает уход за растениями и повышает эффективность использования воды. Система позволяет автоматизировать процесс полива на основе различных параметров: уровня влажности почвы, времени или заданных интервалов. Это не только экономит ресурсы, но и позволяет обеспечить растения необходимым уходом в зависимости от их потребностей. Применение данной системы может быть полезным как для домашних пользователей, так и для небольших аграрных хозяйств, где требуется автоматизация полива для оптимизации труда и использования воды.

Кроме того, проект способствует развитию навыков в области программирования, работы с датчиками и микроконтроллерами, а также применению теоретических знаний в реальных задачах. Он может быть использован в образовательных целях, помогая студентам и специалистам познакомиться с основами автоматизации и интернета вещей (IoT).

Расширение проекта

Расширение проекта может включать внедрение дополнительных функций и возможностей для улучшения работы системы полива. Некоторые идеи для расширения:

  1. Интеграция с мобильным приложением: Возможность управления системой полива через смартфон или планшет. Пользователи смогут настраивать параметры полива, проверять состояние датчиков и получать уведомления о статусе полива.

  2. Использование солнечных панелей: Для автономной работы системы полива можно добавить солнечные панели для питания помпы и других компонентов, что сделает систему более экологичной и экономичной.

  3. Интеграция с погодными сервисами: Система может учитывать данные о погодных условиях, такие как дождь или температура, чтобы регулировать полив, снижая расход воды в случае дождя или повышая его в сухую погоду.

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

  5. Использование более сложных алгоритмов: Внедрение алгоритмов машинного обучения для предсказания потребностей растений в поливе на основе собранных данных, что повысит эффективность системы.

  6. Интеграция с другими системами умного дома: Система полива может быть интегрирована с другими устройствами умного дома, такими как умные термостаты или освещение, для создания комплексного решения по автоматизации домашнего ухода за растениями.

Видеообзор проекта

Для более детального ознакомления с проектом, вы можете посмотреть видеообзор на платформе Rutube:

Пример использования с Python

Проект полностью реализован на языке Python. Код для работы с автоматической системой полива можно найти в репозитории на платформе Gitflic.


Комментарии (0)

Для участия в обсуждении Вы должны быть авторизованным пользователем

Еще посты по теме

Новые посты



Темы

Навигация

ВойтиРегистрация