ESP32 and SHT40 Smart Greenhouse: Wiring, Heater Control and Fault-Safe Code

Sensor Capabilities and Application Limits

Key SHT40 Specifications

The accuracy curves in the datasheet depend on environmental conditions. Near the extremes of the temperature and humidity ranges, maximum errors are generally higher than in the primary operating region.

Include hysteresis when defining control thresholds, and do not interpret small changes in a single measurement as definitive environmental changes.

Selecting Within the SHT4x Family

Check the complete orderable part number. The current SHT4x datasheet describes a polyimide-membrane option and a removable protective-cover option.

Select protection against the actual spray, dust and chemical exposure, then verify response time and service access in the final installation. Do not assume every breakout board carries the same protection.

System Architecture and Hardware Wiring

Control-System Boundaries

Greenhouse systems should separate sensing, decision-making, and actuation.

The SHT40 measures ambient temperature and relative humidity; the ESP32 validates the data and executes threshold logic and the state machine; relays or drivers only switch the loads.

Spray-pump operation must have an independent trigger, preferably soil moisture content, an irrigation schedule, or a manual command.

The diagram-like photo above is not a wiring schematic. The table below is the electrical connection reference for the low-voltage sensor path; the relay module and loads require their own reviewed schematics.

ESP32-to-SHT40 Wiring

Before using a third-party SHT40 breakout board, review its schematic. A board incorporating a voltage regulator and bidirectional level shifter may accept 5 V on VIN. If it contains only the sensor and pull-up resistors, use 3.3 V.

Do not infer the voltage rating from the connector silkscreen alone.

I²C Bus Wiring

Verify the low-voltage bus before connecting any actuator. These four checks prevent an address scan from being mistaken for a reliable measurement.

Relay and Load Safety

An ESP32 GPIO cannot drive a relay coil, pump or fan directly. Select a driver for the actual load and 3.3 V input logic. Check its schematic: an optocoupler or removed jumper alone does not prove galvanic isolation or eliminate the need for a shared ground.

Greenhouse Installation and Environmental Protection

Sensor Placement

Breathable Water-Repellent Protection and Maintenance

A breathable, water-repellent barrier can reduce direct droplet and dust exposure, but it does not make an entire sensor assembly waterproof.

Specify the barrier and housing separately, keep an air path to the opening, provide drainage and inspection access, and validate the response time.

Keep detergents, solvents, uncured adhesives and direct compressed air away from the sensing opening.

Integrated Heater and Measurement Validity

Correct Heater Invocation Sequence

In the Adafruit SHT4x library, setHeater() stores the mode for the next read. getEvent() sends the matching measurement or heater command and waits for its response.

Select one heater mode, call getEvent() once, restore SHT4X_NO_HEATER, and wait for the installed sensor to settle before normal control resumes. The heated reading confirms a transaction, not ambient greenhouse conditions.

sht4.setHeater(SHT4X_MED_HEATER_1S);
sensors_event_t heaterHumidity, heaterTemperature;
bool heaterOk = sht4.getEvent(&heaterHumidity, &heaterTemperature);
sht4.setHeater(SHT4X_NO_HEATER);
 
// heaterHumidity and heaterTemperature are affected by sensor self-heating
// Do not use these values as inputs to fan, cooling-pad, or alarm control
cooldownStart = millis();
state = COOLING_DOWN;

Six Heater Operating Modes

The datasheet defines three heater power settings and two pulse durations. Do not derive an automatic heater schedule from one relative-humidity threshold alone: require sustained conditions, a minimum interval and a spray interlock.

Cooldown depends on the installed sensor and airflow. Persistent liquid exposure calls for a placement or protection change, not repeated heater pulses.

Recommended State Machine

ESP32 Reference Firmware

The complete sketch below is an ESP32 Arduino reference for a normally closed-loop greenhouse prototype: it samples the SHT40, applies fan hysteresis, accepts an S command for a single bench-test spray cycle, blocks control updates during heater and cooldown, and enters a fault state after repeated read failures.

The heater read can block the loop for approximately one second in the chosen mode, so this is a timed state machine rather than a fully non-blocking implementation. Disconnect live loads while validating the example.

#include <Wire.h>
#include <Adafruit_SHT4x.h>
 
constexpr uint8_t PIN_SDA = 21;
constexpr uint8_t PIN_SCL = 22;
constexpr uint8_t PIN_FAN = 25;
constexpr uint8_t PIN_SPRAY = 26;
constexpr bool RELAY_ACTIVE_LOW = true;
 
constexpr uint32_t SAMPLE_MS = 5000;
constexpr uint32_t SPRAY_MS = 10000;
constexpr uint32_t COOLDOWN_MS = 5000;
constexpr uint32_t HEATER_MIN_INTERVAL_MS = 10UL * 60UL * 1000UL;
constexpr float FAN_HUM_ON = 85.0f;
constexpr float FAN_HUM_OFF = 80.0f;
constexpr float FAN_TEMP_ON = 30.0f;
constexpr float FAN_TEMP_OFF = 28.0f;
constexpr float HEATER_HUM_TRIGGER = 90.0f;
constexpr uint8_t MAX_SENSOR_FAILURES = 3;
 
Adafruit_SHT4x sht4;
 
enum class State { NORMAL, SPRAYING, HEATER_MEASUREMENT,
                   COOLING, SENSOR_FAULT };
State state = State::NORMAL;
 
uint32_t lastSample = 0;
uint32_t sprayStarted = 0;
uint32_t cooldownStarted = 0;
uint32_t lastHeater = 0;
float validTemperature = NAN;
float validHumidity = NAN;
uint8_t sensorFailures = 0;
uint8_t recoverySamples = 0;
uint8_t highHumiditySamples = 0;
bool fanOn = false;
 
bool elapsed(uint32_t now, uint32_t since, uint32_t interval) {
  return static_cast<uint32_t>(now - since) >= interval;
}
 
void writeRelay(uint8_t pin, bool on) {
  digitalWrite(pin, RELAY_ACTIVE_LOW ? !on : on);
}
 
void setFan(bool on) {
  fanOn = on;
  writeRelay(PIN_FAN, on);
}
 
void enterSafeState() {
  writeRelay(PIN_SPRAY, false);
  setFan(true);  // Example policy; validate against crop and climate risks on site
}
 
bool readNormalSample() {
  sensors_event_t humidity, temperature;
  sht4.setHeater(SHT4X_NO_HEATER);
  if (!sht4.getEvent(&humidity, &temperature)) return false;
  if (!isfinite(temperature.temperature) || !isfinite(humidity.relative_humidity)) return false;
  validTemperature = temperature.temperature;
  validHumidity = humidity.relative_humidity;
  Serial.printf("T %.2f C  RH %.2f %%\n",
                validTemperature, validHumidity);
  return true;
}
 
void updateFanControl() {
  if (isnan(validTemperature) || isnan(validHumidity)) return;
  if (!fanOn && (validHumidity >= FAN_HUM_ON ||
                 validTemperature >= FAN_TEMP_ON)) {
    setFan(true);
  } else if (fanOn && validHumidity <= FAN_HUM_OFF &&
             validTemperature <= FAN_TEMP_OFF) {
    setFan(false);
  }
}
 
void startSpray(uint32_t now) {
  setFan(false);                 // Example interlock; verify crop and airflow impact
  highHumiditySamples = 0;
  writeRelay(PIN_SPRAY, true);
  sprayStarted = now;
  state = State::SPRAYING;
}
 
void runHeaterMeasurement(uint32_t now) {
  sensors_event_t ignoredHumidity, ignoredTemperature;
  sht4.setHeater(SHT4X_MED_HEATER_1S);
  bool ok = sht4.getEvent(&ignoredHumidity, &ignoredTemperature);
  sht4.setHeater(SHT4X_NO_HEATER);
  if (!ok) {
    state = State::SENSOR_FAULT;
    enterSafeState();
    return;
  }
  lastHeater = now;
  cooldownStarted = millis();
  state = State::COOLING;
}
 
void setup() {
  Serial.begin(115200);
  writeRelay(PIN_FAN, false);  // Set output latch before enabling GPIO output
  writeRelay(PIN_SPRAY, false);
  pinMode(PIN_FAN, OUTPUT);
  pinMode(PIN_SPRAY, OUTPUT);
 
  Wire.begin(PIN_SDA, PIN_SCL);
  Wire.setClock(100000);
  if (!sht4.begin(&Wire)) {
    state = State::SENSOR_FAULT;
    enterSafeState();
    return;
  }
  sht4.setPrecision(SHT4X_HIGH_PRECISION);
  sht4.setHeater(SHT4X_NO_HEATER);
}
 
void loop() {
  const uint32_t now = millis();
 
  // Test command: send S over the serial interface to initiate one spray cycle
  if (state == State::NORMAL && Serial.available() &&
      Serial.read() == 'S') {
    startSpray(now);
  }
 
  switch (state) {
    case State::NORMAL:
      if (elapsed(now, lastSample, SAMPLE_MS)) {
        lastSample = now;
        if (readNormalSample()) {
          sensorFailures = 0;
          updateFanControl();
          if (validHumidity >= HEATER_HUM_TRIGGER) {
            if (highHumiditySamples < 3) ++highHumiditySamples;
          } else {
            highHumiditySamples = 0;
          }
          if (highHumiditySamples >= 3 &&
              elapsed(now, lastHeater, HEATER_MIN_INTERVAL_MS)) {
            highHumiditySamples = 0;
            state = State::HEATER_MEASUREMENT;
          }
        } else {
          highHumiditySamples = 0;
          if (++sensorFailures >= MAX_SENSOR_FAILURES) {
            state = State::SENSOR_FAULT;
            enterSafeState();
          }
        }
      }
      break;
 
    case State::SPRAYING:
      if (elapsed(now, sprayStarted, SPRAY_MS)) {
        writeRelay(PIN_SPRAY, false);
        cooldownStarted = now;
        state = State::COOLING;  // Spraying does not itself request a heater pulse
      }
      break;
 
    case State::HEATER_MEASUREMENT:
      runHeaterMeasurement(now);
      break;
 
    case State::COOLING:
      if (elapsed(now, cooldownStarted, COOLDOWN_MS)) {
        lastSample = now;
        state = State::NORMAL;
      }
      break;
 
    case State::SENSOR_FAULT:
      // Retry sensor initialization every 30 s; require three consecutive valid samples before leaving fault mode
      if (elapsed(now, lastSample, 30000)) {
        lastSample = now;
        if (sht4.begin(&Wire) && readNormalSample()) {
          if (++recoverySamples >= 3) {
            sensorFailures = 0;
            recoverySamples = 0;
            state = State::NORMAL;
            updateFanControl();
          }
        } else {
          recoverySamples = 0;
        }
      }
      break;
  }
}

Parameters to Verify Before Using the Code

Commissioning and Acceptance Testing

Bring Up the System in Six Stages

Start with the sensor alone. Add the driver and live loads only after each earlier stage passes.

1. Prepare the IDEInstall the correct ESP32 board package. Select the exact board and serial port.
2. Install the sensor libraryInstall Adafruit SHT4x with its BusIO and Unified Sensor dependencies.
3. Prove the I²C readingConnect only the ESP32 and SHT40. Run the official SHT4test example; confirm the expected 0x44 address and stable readings.
4. Check the relay without AC loadsVerify the module defaults to off at power-up and confirm its active-high or active-low input behavior.
5. Exercise the reference firmwareSend S through the serial port. Observe spray, heated measurement, cooldown and return to normal sampling.
6. Connect the final loadsOnly after the preceding tests, have qualified personnel inspect mains protection, grounding and the enclosure.

Fault-Injection Tests

Troubleshooting Guide

Recommended Deployment Bill of Materials

Pre-Deployment Checklist

Scope and limitations

Set thresholds, heater intervals and cooldown times through on-site testing; the 5-second example is not a confirmed recovery time. For mains-powered or unattended equipment, use qualified electrical protection and hardware interlocks. Firmware safeguards alone are not a safety system.

Start with the basic ESP32–SHT40 readout if I²C acquisition is not yet stable. For unexplained offsets, see the accuracy guide; for heater effects, see heater diagnostics.

SHT40 and SHT4x are Sensirion identifiers. NYFEA and FHT40 are independent products and are not affiliated with or endorsed by Sensirion. Illustrative images on this page are not installation records or performance evidence.