2
1

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

Raspberry Piとセンサーで「植物の状態を推定するAI」を作ってみた 〜ガジュマルのストレス度・健康度・幸福度を計算し、Geminiで発話させる〜

2
Posted at

はじめに

私は動物が好きです。

犬や猫などの動物は、お世話をすると喜んでくれたり、近づいてきたりと、何らかの反応を返してくれます。その反応があることで、より愛着が湧き、お世話を続けるモチベーションにもつながります。

一方で、植物は元気なのか、水が欲しいのか、現在の環境を快適に感じているのかが分かりづらいと感じていました。

そこで今回は、Raspberry Piと複数のセンサーを使って植物周辺の環境を取得し、ガジュマルの状態を数値化しました。

さらに、推定した状態から感情ラベルを決定し、最後にGeminiを使って、ペットのような自然な発話へ変換するWebアプリを作成しました。

IMG_7686.JPG

作ったもの

今回作成したシステムでは、次の情報を取得します。

  • 人が植物に近づいたか
  • 周囲の温度
  • 周囲の湿度
  • 周囲の明るさ
  • 土が乾燥しているか

取得した情報をそのまま生成AIへ渡すのではなく、Python側で次の処理を行います。

  1. センサーデータを取得
  2. 温度と湿度からVPDを計算
  3. Stress・Health・Happinessを算出
  4. 状態とセンサー情報から感情ラベルを決定
  5. 感情ラベルをGeminiへ渡して発話を生成
  6. Flaskで作ったWeb画面へ表示
センサーデータ
    ↓
特徴量生成
    ↓
状態推定
    ↓
感情推定
    ↓
Geminiによる言葉生成
    ↓
Web画面へ表示

システム構成

ハードウェア

使用したもの 用途
Raspberry Pi 4 センサー制御、状態推定、Webサーバー
ガジュマル 今回状態を推定する植物
No.12 人感センサー 人の接近を検知
No.14 温湿度センサー 温度・湿度を取得
No.24 光センサー 周囲の明るさを取得
No.32 土壌水分センサー 土の乾燥状態を取得
ブレッドボード 電源とGNDの分配
ジャンパーワイヤ Raspberry Piとセンサーの接続

ソフトウェア

使用技術 用途
Python センサー取得、特徴量生成、状態・感情推定
Flask Web画面とAPIの提供
GPIO Zero GPIOから人感・光・土壌状態を取得
Adafruit CircuitPython DHT 温度・湿度を取得
Gemini API 感情ラベルを自然な発話へ変換
HTML / CSS / JavaScript 状態をブラウザへ表示

配線

今回使用したGPIOは次のとおりです。

センサー センサー側 GPIO番号 物理ピン番号
No.12 人感センサー S GPIO17 11
No.14 温湿度センサー S GPIO18 12
No.24 光センサー S GPIO23 16
No.32 土壌水分センサー S GPIO24 18

GNDはブレッドボード上で共有しました。

電源については、使用するモジュールの仕様を確認してください。

今回使用したNo.14 温湿度センサーは、3.3Vでは読み取りに失敗しましたが、5Vへ変更すると正常に動作しました。

[!WARNING]
Raspberry PiのGPIOは3.3Vロジックです。
5Vで動作させるセンサーの信号線が5Vを出力する場合、そのままGPIOへ入力すると故障するおそれがあります。使用するモジュールの回路・出力電圧を確認し、必要に応じてレベル変換回路を使用してください。

環境構築

仮想環境の作成

mkdir -p ~/plant_ai
cd ~/plant_ai

python3 -m venv .venv
source .venv/bin/activate

ライブラリのインストール

python -m pip install --upgrade pip

python -m pip install \
  Flask \
  python-dotenv \
  gpiozero \
  adafruit-blinka \
  adafruit-circuitpython-dht \
  google-genai

OSや環境によっては、GPIOやDHTセンサーの利用に追加のシステムパッケージが必要になる場合があります。

APIキーの設定

Google AI StudioでGemini APIキーを発行し、プロジェクト直下に.envを作成します。

nano .env
GEMINI_API_KEY=ここにAPIキーを設定
GEMINI_MODEL=gemini-2.5-flash-lite

APIキーをGitへ誤って登録しないよう、.gitignoreも作成します。

cat > .gitignore << 'EOF'
.venv/
.env
__pycache__/
*.pyc
EOF

状態推定の考え方

今回のポイントは、取得したセンサー値をそのままGeminiへ渡していないことです。

状態推定と感情推定はPython側で実装し、Geminiは最後の「自然な発話への変換」に限定して利用します。

1. VPDの計算

温度と湿度から、空気の乾燥しやすさを表すVPDを計算します。

飽和水蒸気圧を次の式で求めます。

$$
SVP = 0.6108 \times
\exp\left(
\frac{17.27T}{T + 237.3}
\right)
$$

実際の水蒸気圧は次のとおりです。

$$
AVP = SVP \times \frac{RH}{100}
$$

VPDは両者の差として計算します。

$$
VPD = SVP - AVP
$$

  • $T$:気温
  • $RH$:相対湿度
  • $SVP$:飽和水蒸気圧
  • $AVP$:実際の水蒸気圧

Pythonでは次のように実装しました。

def calc_vpd(temp_c: float, humidity: float) -> float:
    svp = 0.6108 * math.exp(
        (17.27 * temp_c) / (temp_c + 237.3)
    )
    avp = svp * humidity / 100
    return svp - avp

2. 温度・湿度・VPDのリスク変換

温度などの値は、単純に「閾値を超えたら危険」とするのではなく、最適値から離れるほどリスクが高くなる形にしました。

$$
R(x) =
100 \left(
1 -
\exp\left(
-\frac{(x-\mu)^2}{2\sigma^2}
\right)
\right)
$$

  • $x$:現在のセンサー値
  • $\mu$:快適と仮定した中心値
  • $\sigma$:許容範囲の広さ
  • $R(x)$:0〜100のリスク値
def gaussian_risk(
    value: float,
    optimal: float,
    sigma: float
) -> float:
    comfort = math.exp(
        -((value - optimal) ** 2) /
        (2 * sigma ** 2)
    )
    return max(0, min(100, (1 - comfort) * 100))

今回の初期値は次のように設定しました。

特徴量 中心値 $\sigma$
温度 25℃ 5
湿度 60% 20
VPD 0.8kPa 0.45

[!NOTE]
これらの数値は、今回のプロトタイプで状態変化を表現するために設定した初期パラメータです。
ガジュマルを対象に、生理学的な実験によって検証されたモデルではありません。今後、長期間の実測データや植物の変化を用いて調整する必要があります。

3. Stressの算出

植物への負担を、0〜100のStressとして表現しました。

$$
Stress =
0.35R_{soil}
+0.25R_{vpd}
+0.20R_{temp}
+0.10R_{humidity}
+0.10R_{light}
$$

リスク 重み
土壌乾燥 0.35
VPD 0.25
温度 0.20
湿度 0.10
光不足 0.10
soil_risk = 0 if soil_wet else 85
light_risk = 0 if bright else 45

stress = (
    0.35 * soil_risk
    + 0.25 * vpd_risk
    + 0.20 * temp_risk
    + 0.10 * humidity_risk
    + 0.10 * light_risk
)

土壌乾燥とVPDを大きめにし、水分に関する負荷がStressへ強く影響する設計にしました。

4. Healthの算出

Healthは、Stressが高いほど下がるようにしました。

$$
Health = 100 - 0.7 \times Stress
$$

health = 100 - stress * 0.7
health = max(0, min(100, health))

5. Happinessの算出

Happinessは、環境の快適さに加え、人感・明るさ・土壌状態を組み合わせました。

$$
Happiness =
0.55(100-Stress)
+25P
+15L
+10S
$$

  • $P$:人を検知した場合は1、それ以外は0
  • $L$:明るい場合は1、それ以外は0
  • $S$:土が湿っている場合は1、それ以外は0
happiness = (
    (100 - stress) * 0.55
    + int(person) * 25
    + int(bright) * 15
    + int(soil_wet) * 10
)

happiness = max(0, min(100, happiness))

ここでのHappinessは、植物の本当の感情を測定したものではありません。

「環境が快適で、かつ人から見守られている状態」を、人が直感的に理解できる指標として表現したものです。

6. 簡易アラートレベル

現在の実装では、Stressに応じて簡易的なアラートレベルを設定しています。

if stress >= 80:
    alert_level = 3
elif stress >= 65:
    alert_level = 2
elif stress >= 50:
    alert_level = 1
else:
    alert_level = 0

これは過去データを使った統計的な異常検知ではありません。

本格的な異常検知を行うには、時系列データを蓄積し、通常時の分布や季節性と比較する必要があります。

感情推定

状態推定で求めたStress・Health・Happinessに、一部のセンサー情報を加えて感情ラベルを決定します。

def estimate_emotion(
    stress: float,
    health: float,
    happiness: float,
    person: bool,
    bright: bool,
    soil_wet: bool,
) -> str:
    if not soil_wet and stress >= 60:
        return "thirsty"

    if stress >= 75:
        return "tired"

    if person and happiness >= 60:
        return "happy_to_see_you"

    if happiness >= 80:
        return "very_happy"

    if not bright:
        return "sleepy"

    if happiness < 45:
        return "lonely"

    return "calm"

例えば、次のような判定になります。

条件 感情ラベル
土が乾いていてStressが高い thirsty
Stressが非常に高い tired
人を検知しHappinessが高い happy_to_see_you
Happinessが非常に高い very_happy
周囲が暗い sleepy
Happinessが低い lonely
その他 calm

条件は上から順番に評価されるため、ルールの順序も判定結果へ影響します。

Geminiの役割

Geminiには、生のセンサー値から植物の状態を判断させていません。

Python側で決定した感情ラベルと状態指標を渡し、ペットのような自然な日本語へ変換する役割だけを任せています。

emotion=happy_to_see_you
stress=12.5
health=91.2
happiness=86.4

この情報を渡すことで、例えば次のような発話を生成します。

来てくれたー!
今日は一緒にいられてうれしい!
ちょっとお水ほしいかも…

全体コード

以下が、センサー取得・状態推定・感情推定・Gemini・Web表示をまとめたコードです。

plant_web.pyとして保存します。

import math
import os
import threading
import time
from datetime import datetime
from typing import Any

import adafruit_dht
import board
from dotenv import load_dotenv
from flask import Flask, jsonify, render_template_string
from google import genai
from google.genai import types
from gpiozero import InputDevice


# ============================================================
# Configuration
# ============================================================

SENSOR_INTERVAL_SEC = 3
GEMINI_MIN_INTERVAL_SEC = 60
GEMINI_PERIODIC_INTERVAL_SEC = 15 * 60

LIGHT_BRIGHT_VALUE = 1
SOIL_WET_VALUE = 1

PIN_PIR = 17
PIN_LIGHT = 23
PIN_SOIL = 24

load_dotenv()

api_key = os.getenv("GEMINI_API_KEY")
if not api_key:
    raise RuntimeError("GEMINI_API_KEY is not set.")

gemini_model = os.getenv(
    "GEMINI_MODEL",
    "gemini-2.5-flash-lite",
)

client = genai.Client(api_key=api_key)

app = Flask(__name__)


# ============================================================
# Sensor initialization
# ============================================================

# No.12 PIR Motion Sensor
pir_sensor = InputDevice(PIN_PIR, pull_up=False)

# No.14 Temperature & Humidity Sensor
dht_sensor = adafruit_dht.DHT11(
    board.D18,
    use_pulseio=False,
)

# No.24 Photocell Sensor
light_sensor = InputDevice(PIN_LIGHT, pull_up=False)

# No.32 Soil Humidity Sensor
soil_sensor = InputDevice(PIN_SOIL, pull_up=False)


# ============================================================
# Shared state
# ============================================================

status_lock = threading.Lock()

latest_status: dict[str, Any] = {
    "ok": False,
    "error": "Starting...",
}

last_message = "Waiting..."
last_emotion: str | None = None
last_person = False
last_gemini_time = 0.0


# ============================================================
# Utility functions
# ============================================================

def clamp(
    value: float,
    low: float = 0,
    high: float = 100,
) -> float:
    return max(low, min(high, value))


def calc_vpd(
    temp_c: float,
    humidity: float,
) -> float:
    svp = 0.6108 * math.exp(
        (17.27 * temp_c) /
        (temp_c + 237.3)
    )

    avp = svp * humidity / 100
    return svp - avp


def gaussian_risk(
    value: float,
    optimal: float,
    sigma: float,
) -> float:
    comfort = math.exp(
        -((value - optimal) ** 2) /
        (2 * sigma ** 2)
    )

    return clamp((1 - comfort) * 100)


# ============================================================
# Sensor reading
# ============================================================

def read_dht(
    max_retry: int = 5,
) -> tuple[float, float]:
    for _ in range(max_retry):
        try:
            temp = dht_sensor.temperature
            humidity = dht_sensor.humidity

            if temp is not None and humidity is not None:
                return float(temp), float(humidity)

        except RuntimeError:
            time.sleep(1)

    raise RuntimeError(
        "No.14 DHT sensor read failed."
    )


def read_sensors() -> dict[str, Any]:
    temp, humidity = read_dht()

    person = bool(pir_sensor.value)

    light_raw = int(light_sensor.value)
    soil_raw = int(soil_sensor.value)

    bright = light_raw == LIGHT_BRIGHT_VALUE
    soil_wet = soil_raw == SOIL_WET_VALUE

    return {
        "temp": temp,
        "humidity": humidity,
        "person": person,
        "bright": bright,
        "soil_wet": soil_wet,
    }


# ============================================================
# State estimation
# ============================================================

def estimate_emotion(
    stress: float,
    health: float,
    happiness: float,
    person: bool,
    bright: bool,
    soil_wet: bool,
) -> str:
    if not soil_wet and stress >= 60:
        return "thirsty"

    if stress >= 75:
        return "tired"

    if person and happiness >= 60:
        return "happy_to_see_you"

    if happiness >= 80:
        return "very_happy"

    if not bright:
        return "sleepy"

    if happiness < 45:
        return "lonely"

    return "calm"


def estimate_status() -> dict[str, Any]:
    sensor_data = read_sensors()

    temp = sensor_data["temp"]
    humidity = sensor_data["humidity"]
    person = sensor_data["person"]
    bright = sensor_data["bright"]
    soil_wet = sensor_data["soil_wet"]

    vpd = calc_vpd(temp, humidity)

    temp_risk = gaussian_risk(
        temp,
        optimal=25,
        sigma=5,
    )

    humidity_risk = gaussian_risk(
        humidity,
        optimal=60,
        sigma=20,
    )

    vpd_risk = gaussian_risk(
        vpd,
        optimal=0.8,
        sigma=0.45,
    )

    soil_risk = 0 if soil_wet else 85
    light_risk = 0 if bright else 45

    stress = (
        0.35 * soil_risk
        + 0.25 * vpd_risk
        + 0.20 * temp_risk
        + 0.10 * humidity_risk
        + 0.10 * light_risk
    )

    stress = clamp(stress)

    health = clamp(
        100 - stress * 0.7
    )

    happiness = clamp(
        (100 - stress) * 0.55
        + int(person) * 25
        + int(bright) * 15
        + int(soil_wet) * 10
    )

    if stress >= 80:
        alert_level = 3
    elif stress >= 65:
        alert_level = 2
    elif stress >= 50:
        alert_level = 1
    else:
        alert_level = 0

    emotion = estimate_emotion(
        stress=stress,
        health=health,
        happiness=happiness,
        person=person,
        bright=bright,
        soil_wet=soil_wet,
    )

    return {
        "ok": True,
        "time": datetime.now().strftime(
            "%Y-%m-%d %H:%M:%S"
        ),
        "temp": round(temp, 1),
        "humidity": round(humidity, 1),
        "vpd": round(vpd, 3),
        "person": person,
        "bright": bright,
        "soil_wet": soil_wet,
        "stress": round(stress, 1),
        "health": round(health, 1),
        "happiness": round(happiness, 1),
        "alert_level": alert_level,
        "emotion": emotion,
    }


# ============================================================
# Gemini
# ============================================================

def should_generate_message(
    status: dict[str, Any],
) -> bool:
    global last_person

    now = time.time()

    first_generation = last_emotion is None
    person_rising = (
        status["person"]
        and not last_person
    )

    emotion_changed = (
        status["emotion"] != last_emotion
    )

    periodic_generation = (
        now - last_gemini_time
        >= GEMINI_PERIODIC_INTERVAL_SEC
    )

    minimum_interval_elapsed = (
        now - last_gemini_time
        >= GEMINI_MIN_INTERVAL_SEC
    )

    last_person = status["person"]

    if first_generation:
        return True

    if not minimum_interval_elapsed:
        return False

    return (
        person_rising
        or emotion_changed
        or periodic_generation
    )


def build_prompt(
    status: dict[str, Any],
) -> str:
    return f"""
You are the spirit of a gajumaru plant.

Personality:
- Like a small pet
- Friendly and attached to the owner
- A little spoiled
- Honest and simple

Rules:
- Output Japanese
- Output only one short sentence
- Use 10 to 28 Japanese characters
- Talk directly to the owner
- Do not mention numbers or sensor names
- Do not write a poem
- Do not use literary or philosophical expressions
- Do not use polite language

Estimated state:
emotion={status["emotion"]}
stress={status["stress"]}
health={status["health"]}
happiness={status["happiness"]}
alert_level={status["alert_level"]}
person_near={status["person"]}
bright={status["bright"]}
soil_wet={status["soil_wet"]}
""".strip()


def generate_message(
    status: dict[str, Any],
) -> str:
    global last_message
    global last_emotion
    global last_gemini_time

    if not should_generate_message(status):
        return last_message

    try:
        response = client.models.generate_content(
            model=gemini_model,
            contents=build_prompt(status),
            config=types.GenerateContentConfig(
                temperature=0.8,
                max_output_tokens=64,
            ),
        )

        message = response.text.strip()
        message = message.replace("\n", "")

        if message:
            last_message = message

        last_emotion = status["emotion"]
        last_gemini_time = time.time()

    except Exception as error:
        print(f"Gemini API error: {error}")

    return last_message


# ============================================================
# Background sensor loop
# ============================================================

def sensor_loop() -> None:
    global latest_status

    while True:
        try:
            status = estimate_status()
            status["message"] = generate_message(status)

        except Exception as error:
            status = {
                "ok": False,
                "error": str(error),
                "time": datetime.now().strftime(
                    "%Y-%m-%d %H:%M:%S"
                ),
            }

        with status_lock:
            latest_status = status

        time.sleep(SENSOR_INTERVAL_SEC)


# ============================================================
# Web UI
# ============================================================

HTML = """
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta
    name="viewport"
    content="width=device-width, initial-scale=1"
  >
  <title>Gajumaru AI</title>

  <style>
    body {
      margin: 0;
      padding: 28px;
      background: #f4f5f7;
      color: #222;
      font-family:
        Arial,
        Helvetica,
        sans-serif;
    }

    .card {
      max-width: 760px;
      margin: auto;
      padding: 28px;
      border-radius: 18px;
      background: white;
      box-shadow:
        0 4px 20px rgba(0, 0, 0, 0.12);
    }

    h1 {
      margin-top: 0;
      font-size: 34px;
    }

    .message {
      margin: 22px 0;
      padding: 22px;
      border-radius: 14px;
      background: #eef8ee;
      font-size: 28px;
      font-weight: 700;
    }

    .emotion {
      margin-bottom: 20px;
      padding: 12px;
      border-radius: 10px;
      background: #f7f7f7;
    }

    .grid {
      display: grid;
      grid-template-columns:
        repeat(2, minmax(0, 1fr));
      gap: 12px;
    }

    .item {
      padding: 14px;
      border-radius: 10px;
      background: #fafafa;
    }

    .metric {
      margin: 20px 0;
    }

    .metric-title {
      font-size: 18px;
      font-weight: 700;
    }

    .bar {
      height: 20px;
      margin-top: 8px;
      overflow: hidden;
      border-radius: 12px;
      background: #ddd;
    }

    .fill {
      width: 0;
      height: 100%;
      background: #68a063;
      transition: width 0.4s;
    }

    .small {
      margin-top: 22px;
      color: #666;
      font-size: 14px;
    }

    @media (max-width: 600px) {
      body {
        padding: 12px;
      }

      .card {
        padding: 18px;
      }

      .grid {
        grid-template-columns: 1fr;
      }

      .message {
        font-size: 22px;
      }
    }
  </style>
</head>

<body>
  <main class="card">
    <h1>Gajumaru AI</h1>

    <div class="message" id="message">
      Loading...
    </div>

    <div class="emotion">
      Emotion:
      <span id="emotion">-</span>
    </div>

    <div class="grid">
      <div class="item">
        Temp:
        <span id="temp">-</span> C
      </div>

      <div class="item">
        Humidity:
        <span id="humidity">-</span> %
      </div>

      <div class="item">
        VPD:
        <span id="vpd">-</span> kPa
      </div>

      <div class="item">
        Person:
        <span id="person">-</span>
      </div>

      <div class="item">
        Light:
        <span id="bright">-</span>
      </div>

      <div class="item">
        Soil:
        <span id="soil">-</span>
      </div>
    </div>

    <div class="metric">
      <div class="metric-title">Stress</div>
      <div class="bar">
        <div class="fill" id="stress-bar"></div>
      </div>
      <p id="stress">-</p>
    </div>

    <div class="metric">
      <div class="metric-title">Health</div>
      <div class="bar">
        <div class="fill" id="health-bar"></div>
      </div>
      <p id="health">-</p>
    </div>

    <div class="metric">
      <div class="metric-title">
        Happiness
      </div>
      <div class="bar">
        <div class="fill" id="happiness-bar"></div>
      </div>
      <p id="happiness">-</p>
    </div>

    <div class="metric">
      <div class="metric-title">
        Alert Level
      </div>
      <p id="alert-level">-</p>
    </div>

    <p class="small">
      Updated:
      <span id="time">-</span>
    </p>
  </main>

  <script>
    async function updateStatus() {
      try {
        const response = await fetch("/api/status");
        const data = await response.json();

        if (!data.ok) {
          document.getElementById(
            "message"
          ).textContent =
            "Sensor error: " + data.error;
          return;
        }

        document.getElementById(
          "message"
        ).textContent =
          "Gajumaru: " + data.message;

        document.getElementById(
          "emotion"
        ).textContent = data.emotion;

        document.getElementById(
          "temp"
        ).textContent = data.temp;

        document.getElementById(
          "humidity"
        ).textContent = data.humidity;

        document.getElementById(
          "vpd"
        ).textContent = data.vpd;

        document.getElementById(
          "person"
        ).textContent =
          data.person ? "Near" : "None";

        document.getElementById(
          "bright"
        ).textContent =
          data.bright ? "Bright" : "Dark";

        document.getElementById(
          "soil"
        ).textContent =
          data.soil_wet ? "Wet" : "Dry";

        document.getElementById(
          "stress"
        ).textContent =
          data.stress + " / 100";

        document.getElementById(
          "health"
        ).textContent =
          data.health + " / 100";

        document.getElementById(
          "happiness"
        ).textContent =
          data.happiness + " / 100";

        document.getElementById(
          "alert-level"
        ).textContent =
          data.alert_level + " / 3";

        document.getElementById(
          "stress-bar"
        ).style.width =
          data.stress + "%";

        document.getElementById(
          "health-bar"
        ).style.width =
          data.health + "%";

        document.getElementById(
          "happiness-bar"
        ).style.width =
          data.happiness + "%";

        document.getElementById(
          "time"
        ).textContent = data.time;

      } catch (error) {
        document.getElementById(
          "message"
        ).textContent = "API error";
      }
    }

    setInterval(updateStatus, 3000);
    updateStatus();
  </script>
</body>
</html>
"""


@app.route("/")
def index():
    return render_template_string(HTML)


@app.route("/api/status")
def api_status():
    with status_lock:
        return jsonify(dict(latest_status))


if __name__ == "__main__":
    thread = threading.Thread(
        target=sensor_loop,
        daemon=True,
    )
    thread.start()

    print(
        "Open http://127.0.0.1:5000"
    )

    app.run(
        host="0.0.0.0",
        port=5000,
        debug=False,
        threaded=True,
    )

実行

source ~/plant_ai/.venv/bin/activate
cd ~/plant_ai

python plant_web.py

次のように表示されたら起動成功です。

Running on http://127.0.0.1:5000
Running on http://192.168.xxx.xxx:5000

Raspberry Pi上のブラウザでは、次を開きます。

http://127.0.0.1:5000

同じネットワーク上のPCやスマートフォンからは、Raspberry PiのIPアドレスを指定します。

http://RaspberryPiのIPアドレス:5000

Raspberry PiのIPアドレスは、次のコマンドで確認できます。

hostname -I

スクリーンショット 2026-06-05 8.46.14.png

動作例

人が近づいた場合

Emotion: happy_to_see_you
Gajumaru: 来てくれたー!

土が乾燥している場合

Emotion: thirsty
Gajumaru: ちょっとお水ほしいかも…

周囲が暗い場合

Emotion: sleepy
Gajumaru: ねむくなってきた〜

ハマったポイント

DHT sensor not foundが発生する

No.14 温湿度センサーを3.3Vへ接続した状態では、次のエラーが発生しました。

DHT sensor not found, check wiring

今回使用したモジュールでは、電源を5Vへ変更すると正常に取得できました。

ただし、モジュールの信号出力電圧を確認せず、5V信号をRaspberry PiのGPIOへ入力するのは危険です。使用する製品の仕様を確認する必要があります。

No module named 'board'

Adafruit Blinkaがインストールされていない場合に発生します。

python -m pip install adafruit-blinka

No module named 'adafruit_dht'

DHT用ライブラリをインストールします。

python -m pip install \
  adafruit-circuitpython-dht

Failed to add edge detection

今回の環境では、DigitalInputDeviceを使った際にイベント検知エラーが発生しました。

そのため、No.24 光センサーとNo.32 土壌水分センサーでは、イベント検知を使わず、InputDeviceから現在値を定期取得する方式に変更しました。

light_sensor = InputDevice(
    PIN_LIGHT,
    pull_up=False,
)

soil_sensor = InputDevice(
    PIN_SOIL,
    pull_up=False,
)

Gemini SDKの警告

旧SDKの次の書き方では、非推奨警告が表示されました。

import google.generativeai as genai

今回は新しいGoogle GenAI SDKへ変更しています。

from google import genai

client = genai.Client(
    api_key=api_key
)

現在の課題

光と土壌水分が2値

現在のNo.24 光センサーとNo.32 土壌水分センサーは、GPIOから0または1として読み取っています。

そのため、分かるのは次のような2状態のみです。

Bright / Dark
Wet / Dry

照度や土壌水分を連続値として取得するには、MCP3008などのADCを追加し、アナログ値を読み取る必要があります。

状態推定モデルは仮説ベース

Stress・Health・Happinessの計算式と重みは、今回の体験を成立させるために設計した初期モデルです。

現時点では、ガジュマルの生育状態との対応を長期間検証したものではありません。

今後は、センサー値と次の情報を継続的に記録し、パラメータを調整したいと考えています。

  • 水やりの日時
  • 葉の変色
  • 落葉の有無
  • 新芽の数
  • 土壌水分の変化
  • 日照時間
  • 室温・湿度の推移

異常検知が固定閾値

現在のAlert Levelは、Stressの固定閾値による簡易判定です。

今後、時系列データをSQLiteなどへ保存し、次のような方法を試したいです。

  • 移動平均
  • zスコア
  • 季節性を考慮した異常検知
  • Isolation Forest
  • 過去の正常状態との距離計算

今後やりたいこと

  • ADCを追加して光と土壌水分を連続値化
  • SQLiteへセンサーデータを保存
  • 時系列グラフをWeb画面へ表示
  • 実測データに基づいて状態推定モデルを調整
  • 統計的な異常検知を追加
  • USBスピーカーで発話
  • マイクを追加して音声対話
  • 植物の種類ごとに状態推定モデルを切り替え
  • 複数の植物を同時に管理

まとめ

Raspberry Piと4種類のセンサーを使い、ガジュマル周辺の環境を取得するシステムを作成しました。

今回の構成では、生のセンサー値をそのまま生成AIへ渡していません。

物理環境を取得
    ↓
特徴量を生成
    ↓
植物の状態を数値化
    ↓
感情ラベルを決定
    ↓
生成AIで自然な発話へ変換

状態推定と感情推定をPython側で行い、Geminiの役割を最後の言葉生成に限定することで、処理内容を把握・調整しやすい構成にしました。

植物に本当の感情があるわけではありません。

それでも、植物の状態を人が理解しやすい言葉へ変換すると、反応のない植物が少しだけペットのように感じられ、お世話への関心や愛着が高まることを実感しました。

2
1
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
2
1

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?