Autonomous Greenhouse Agent with ESP32 and Local LLM Reasoning

Greenhouse growers water on fixed timers or gut feeling: too much water drowns roots, too little stresses the crop, and nobody records why each decision was made. Rule-based automation improves on this but hides its logic in threshold code that is hard for a student to explain in a viva. This project takes a different approach — an agentic IoT design where an ESP32 handles sensing and actuation while a local large language model acts as a supervisory planner, reasoning over soil moisture, temperature and humidity and publishing a plan with a human-readable explanation for every action it takes. The architecture is honest about physics and computing: the planner runs on the student's laptop (not on the microcontroller), its decisions take a few seconds per cycle over MQTT, and all safety interlocks — maximum pump run-time, temperature failsafe — execute on the ESP32 itself, independent of the planner. The student learns the full modern edge-to-agent pipeline: capacitive soil sensing, DHT22 climate sensing, relay-driven actuation, MQTT telemetry, prompt-structured LLM planning, and a real-time dashboard.

1. The capacitive soil probe, DHT22 and LDR continuously measure soil moisture, canopy temperature/humidity and light; the ESP32 publishes the readings over Wi-Fi to MQTT topics every few seconds.
2. A local LLM planner on the student's laptop subscribes to the telemetry topic and, on each cycle, reasons over the readings against the configured thresholds (e.g. soil low 35%, ventilation above 32 °C).
3. When a condition needs action, the planner publishes a structured plan: which actuator, for how long, and a plain-language explanation of why this action and not another.
4. The ESP32 receives the plan, validates it against its hard safety limits (max 90 s pump run, temperature failsafe), executes it, and publishes the resulting actuator state.
5. The dashboard renders live telemetry, actuator states, the moisture trend chart and the rolling explanation log; the operator can edit thresholds, which take effect on the next planner cycle.
6. Safety interlocks run entirely on the ESP32: if MQTT or the laptop goes down, the failsafes still protect the plant and the pump.

Tech stack:

• ESP32 devkit (Arduino C++ firmware)
• MQTT broker (Mosquitto on the student's laptop)
• Local LLM planner (Ollama-class model, structured prompting)
• Web dashboard (single-file HTML/CSS/JS)
• DHT22 · capacitive soil probe · LDR
• Relay module · 5 V mini pump · 12 V fan

• [ESP32 sensor node] A capacitive soil-moisture probe, DHT22 temperature/humidity sensor and an LDR light sensor wired to an ESP32 devkit on a breadboard — the full sensing front-end the dashboard is built around.
• [Relay-driven actuation] Single-channel relay module switches a 5 V mini water pump and a 12 V ventilation fan, so the agent can physically irrigate and ventilate the demo bed.
• [Supervisory LLM planner] A local LLM on the student's laptop subscribes to the MQTT telemetry topics, reasons over the readings against configurable thresholds, and publishes structured plans (action, duration, explanation) to the actuation topic.
• [Explanation log] Every decision the planner makes is stored with its reasoning in plain language — strong viva material, because the student can narrate exactly why the agent watered or ventilated at each moment.
• [Live dashboard] Real-time web dashboard showing soil moisture, temperature, humidity, actuator states, a 60-sample telemetry trend chart and the rolling agent-plan log, with editable planner thresholds.
• [Hard safety cut-offs on the ESP32] Maximum pump run-time (90 s per run, configurable), temperature failsafe and manual override run in the ESP32 firmware and cannot be overridden by the planner.
• [Two-point soil calibration procedure] The student calibrates the capacitive probe against dry and saturated soil references and enters the mapping, so reported moisture percentages come from their own calibration, not a guess.
• [MQTT topic architecture] Clean retained topics for telemetry, plans, status and configuration — the student can demonstrate each message on an MQTT client during the demo.

• Working ESP32 greenhouse prototype: sensors, relay module, mini pump, fan, breadboard wiring
• ESP32 firmware (sensing, MQTT, actuation, safety interlocks, calibration routine)
• Local LLM planner integration on the laptop with structured prompts and threshold configuration
• Live single-file dashboard with telemetry, trend chart and agent-plan log
• Wiring diagram and two-point soil calibration procedure
• Project report PDF (architecture, MQTT design, planner prompting, safety analysis)
• PPT presentation for final review
• Viva Q&A preparation document (agentic IoT, MQTT, ESP32 vs planner responsibilities, LLM latency honesty)

Timeline

• Built-to-order assembly, calibration and testing typically takes 2–3 weeks after order confirmation (expected timeline, confirmed at quotation).
• The planner setup and dashboard are configured in the same window; the report, PPT and viva kit ship with the prototype.

Support

• Remote guidance for setting up the laptop-side MQTT broker and local LLM planner.
• A walkthrough of the agent-plan logic and the explanation log so the student can present it confidently.
• Viva preparation support covering MQTT, ESP32 firmware limits and the supervisory-planner design.