Интеграция датчика температуры DS18B20 с AI-агентом ASI Biont: от аппаратной схемы до предиктивной аналитики

DS18B20 (вид спереди, плоской стороной к себе):
  [1] GND  — GND ESP32
  [2] DQ   — GPIO4 ESP32 (через резистор 4.7 кОм к VCC)
  [3] VCC  — 3.3V ESP32

import machine
import onewire
import ds18x20
import time
import network
from umqtt.simple import MQTTClient

# Настройка Wi-Fi
SSID = "YourWiFi"
PASSWORD = "YourPassword"

def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(SSID, PASSWORD)
    while not wlan.isconnected():
        time.sleep(1)
    print("WiFi connected:", wlan.ifconfig())

# Настройка MQTT
MQTT_BROKER = "broker.hivemq.com"  # или свой брокер
MQTT_TOPIC = b"sensor/temperature"

def publish_temp(client, ds_sensor, roms):
    ds_sensor.convert_temp()
    time.sleep_ms(750)
    for rom in roms:
        temp = ds_sensor.read_temp(rom)
        client.publish(MQTT_TOPIC, str(temp))
        print("Published:", temp)

# Инициализация датчика
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
roms = ds_sensor.scan()
print("Found DS18B20 sensors:", len(roms))

# Подключение
connect_wifi()
client = MQTTClient("esp32_ds18b20", MQTT_BROKER)
client.connect()

while True:
    publish_temp(client, ds_sensor, roms)
    time.sleep(60)  # публикуем каждую минуту

import paho.mqtt.client as mqtt
import matplotlib.pyplot as plt
import io
import json
from datetime import datetime, timedelta
import requests

# Конфигурация
BROKER = "broker.hivemq.com"
TOPIC = "sensor/temperature"
TELEGRAM_TOKEN = "YOUR_BOT_TOKEN"
TELEGRAM_CHAT_ID = "123456789"
ALERT_THRESHOLD = 30.0

temp_history = []  # список словарей: {timestamp, value}

def on_message(client, userdata, msg):
    global temp_history
    try:
        temp = float(msg.payload.decode())
        now = datetime.now()
        temp_history.append({"timestamp": now.isoformat(), "value": temp})
        # Храним только последний час
        cutoff = now - timedelta(hours=1)
        temp_history = [x for x in temp_history if datetime.fromisoformat(x["timestamp"]) > cutoff]

        # Проверка превышения
        if temp > ALERT_THRESHOLD:
            message = f"⚠️ Внимание! Температура превысила {ALERT_THRESHOLD}°C: {temp:.2f}°C"
            url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
            requests.post(url, json={"chat_id": TELEGRAM_CHAT_ID, "text": message})
            print("Alert sent to Telegram")

        # Каждые 5 минут строим график
        if len(temp_history) % 5 == 0:
            plot_temp(temp_history)
    except Exception as e:
        print("Error processing message:", e)

def plot_temp(history):
    timestamps = [datetime.fromisoformat(x["timestamp"]) for x in history]
    values = [x["value"] for x in history]

    plt.figure(figsize=(10, 5))
    plt.plot(timestamps, values, marker='o', linestyle='-', color='b')
    plt.title('Температура DS18B20 (последний час)')
    plt.xlabel('Время')
    plt.ylabel('Температура, °C')
    plt.grid(True)
    plt.xticks(rotation=45)
    plt.tight_layout()

    buf = io.BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)
    # Отправляем график в чат (через base64 или ссылку)
    print("График построен, размер:", len(buf.getvalue()), "байт")
    plt.close()

client = mqtt.Client()
client.on_message = on_message
client.connect(BROKER, 1883, 60)
client.subscribe(TOPIC)
client.loop_start()

# Ждём 30 секунд (таймаут sandbox)
import time
time.sleep(30)
client.loop_stop()

# В /boot/config.txt добавить:
dtoverlay=w1-gpio
# Перезагрузить
sudo reboot

import paramiko
import time
import json
import re

# Параметры подключения
HOST = "192.168.1.100"
USER = "pi"
PASSWORD = "raspberry"

# Подключение по SSH
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(HOST, username=USER, password=PASSWORD)

def read_temp():
    stdin, stdout, stderr = ssh.exec_command("cat /sys/bus/w1/devices/28-*/w1_slave")
    output = stdout.read().decode()
    # Парсинг: вторая строка содержит t=xxxxx
    match = re.search(r't=(\d+)', output)
    if match:
        temp_c = int(match.group(1)) / 1000.0
        return temp_c
    return None

def set_relay(state):
    # Включаем/выключаем реле на GPIO17
    if state:
        cmd = "python3 -c \"import RPi.GPIO as GPIO; GPIO.setmode(GPIO.BCM); GPIO.setup(17, GPIO.OUT); GPIO.output(17, GPIO.HIGH)\""
    else:
        cmd = "python3 -c \"import RPi.GPIO as GPIO; GPIO.setmode(GPIO.BCM); GPIO.setup(17, GPIO.OUT); GPIO.output(17, GPIO.LOW)\""
    ssh.exec_command(cmd)

# Основной цикл (в sandbox — ограничение 30 секунд, поэтому показываем логику)
temp = read_temp()
if temp is not None:
    print(f"Текущая температура: {temp:.2f}°C")
    # Сохраняем в JSON
    data = {"timestamp": time.time(), "temperature": temp}
    with open("/home/pi/temp_log.json", "a") as f:
        f.write(json.dumps(data) + "\n")

    if temp < 5.0:
        set_relay(True)
        print("Температура ниже 5°C — реле включено")
    else:
        set_relay(False)
        print("Температура в норме — реле выключено")
else:
    print("Ошибка чтения датчика")

ssh.close()

import numpy as np
from sklearn.linear_model import LinearRegression
import pandas as pd
import requests

# Загрузка данных (предположим, CSV загружен)
df = pd.read_csv('temperature_history.csv')
df['timestamp'] = pd.to_datetime(df['timestamp'])
df['hours'] = (df['timestamp'] - df['timestamp'].min()).dt.total_seconds() / 3600

X = df['hours'].values.reshape(-1, 1)
y = df['temperature'].values

model = LinearRegression()
model.fit(X, y)

# Прогноз на 2 часа вперёд
last_hour = df['hours'].max()
future_hours = np.array([last_hour + 1, last_hour + 2]).reshape(-1, 1)
predictions = model.predict(future_hours)

print(f"Прогноз на +1 час: {predictions[0]:.2f}°C")
print(f"Прогноз на +2 часа: {predictions[1]:.2f}°C")

if max(predictions) > 28:
    msg = f"🚨 Прогноз: температура превысит 28°C (макс. {max(predictions):.2f}°C)"
    requests.post(f"https://api.telegram.org/bot{TOKEN}/sendMessage",
                  json={"chat_id": CHAT_ID, "text": msg})