Humidity-Temperature Motor Control

#include <Arduino.h>
#include <Wire.h>
#include <DHT.h>
#include <LiquidCrystal_I2C.h>

constexpr uint8_t DHT_PIN = 4;
constexpr uint8_t LIGHT_SENSOR_PIN = 23;
constexpr uint8_t MOTOR_ENABLE_PIN = 27;
constexpr uint8_t MOTOR_DIR_A_PIN = 14;
constexpr uint8_t MOTOR_DIR_B_PIN = 13;
constexpr uint8_t I2C_SDA_PIN = 21;
constexpr uint8_t I2C_SCL_PIN = 22;
constexpr uint8_t DHT_TYPE = DHT11;
constexpr uint8_t LCD_ADDRESS = 0x27;
constexpr unsigned long SAMPLE_INTERVAL_MS = 2000;
constexpr uint8_t MOTOR_PWM_50_PERCENT = 128;  // 128 / 255 is approximately 50% duty cycle.

DHT dht(DHT_PIN, DHT_TYPE);
LiquidCrystal_I2C lcd(LCD_ADDRESS, 16, 2);
unsigned long lastSampleMs = 0;

enum class MotorState { STOP, UP, DOWN };

void setMotor(MotorState state) {
  const bool motorRuns = state != MotorState::STOP;
  // The enable input receives a 50% PWM signal whenever the motor is commanded to move.
  analogWrite(MOTOR_ENABLE_PIN, motorRuns ? MOTOR_PWM_50_PERCENT : 0);
  digitalWrite(MOTOR_DIR_A_PIN, state == MotorState::UP ? HIGH : LOW);
  digitalWrite(MOTOR_DIR_B_PIN, state == MotorState::DOWN ? HIGH : LOW);
}

void printLine(uint8_t row, const char *text) {
  char padded[17];
  snprintf(padded, sizeof(padded), "%-16.16s", text);
  lcd.setCursor(0, row);
  lcd.print(padded);
}

const char *motorStateName(MotorState state) {
  if (state == MotorState::UP) return "UP";
  if (state == MotorState::DOWN) return "DOWN";
  return "STOP";
}

void showReadings(float temperatureC, float humidity, MotorState motorState, bool lightDetected) {
  char line1[17];
  char line2[17];
  snprintf(line1, sizeof(line1), "T:%.1fC H:%.0f%%", temperatureC, humidity);
  snprintf(line2, sizeof(line2), "L:%s M:%s", lightDetected ? "BRIGHT" : "DARK", motorStateName(motorState));
  printLine(0, line1);
  printLine(1, line2);
}

void showSensorError(bool lightDetected) {
  printLine(0, "DHT11 read failed");
  printLine(1, lightDetected ? "L:BRIGHT M:STOP" : "L:DARK M:STOP");
}

void setup() {
  Serial.begin(115200);
  pinMode(MOTOR_ENABLE_PIN, OUTPUT);
  analogWriteResolution(MOTOR_ENABLE_PIN, 8);
  analogWriteFrequency(MOTOR_ENABLE_PIN, 20000);
  pinMode(MOTOR_DIR_A_PIN, OUTPUT);
  pinMode(MOTOR_DIR_B_PIN, OUTPUT);
  pinMode(LIGHT_SENSOR_PIN, INPUT);
  setMotor(MotorState::STOP);

  dht.begin();
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  lcd.init();
  lcd.backlight();
  lcd.clear();
  printLine(0, "Humidity control");
  printLine(1, "Starting...");
}

void loop() {
  const unsigned long now = millis();
  if (now - lastSampleMs < SAMPLE_INTERVAL_MS) return;
  lastSampleMs = now;

  // Typical LM393 light-sensor modules pull DO LOW at the chosen light threshold.
  const bool lightDetected = digitalRead(LIGHT_SENSOR_PIN) == LOW;
  const float humidity = dht.readHumidity();
  const float temperatureC = dht.readTemperature();

  if (isnan(humidity) || isnan(temperatureC)) {
    setMotor(MotorState::STOP);
    Serial.printf("DHT11 read failed; light: %s; motor OFF\n", lightDetected ? "BRIGHT" : "DARK");
    showSensorError(lightDetected);
    return;
  }

  // Temperature has first priority, humidity second, and light third.
  MotorState motorState = MotorState::STOP;
  if (temperatureC > 30.0f) {
    motorState = MotorState::DOWN;
  } else if (temperatureC <= 28.0f) {
    motorState = MotorState::UP;
  } else if (humidity < 70.0f) {
    motorState = MotorState::DOWN;
  } else if (humidity >= 75.0f) {
    motorState = MotorState::UP;
  } else {
    // Light is the final tie-breaker: bright stops the motor; dark moves it up.
    motorState = lightDetected ? MotorState::STOP : MotorState::UP;
  }

  setMotor(motorState);
  Serial.printf("Temperature: %.1f C, Humidity: %.1f %%, Light: %s, Motor: %s\n",
                temperatureC, humidity, lightDetected ? "BRIGHT" : "DARK", motorStateName(motorState));
  showReadings(temperatureC, humidity, motorState, lightDetected);
}