Cloud-Controlled Smart Rover

#include <WiFi.h>
#include <WebServer.h>
#include <PubSubClient.h>

// Fill in these two values when you want cloud MQTT control.
const char* WIFI_SSID = "";
const char* WIFI_PASSWORD = "";
const char* MQTT_HOST = "test.mosquitto.org";
const uint16_t MQTT_PORT = 1883;
const char* MQTT_COMMAND_TOPIC = "schematik/robotcar/cmd";
const char* MQTT_STATUS_TOPIC = "schematik/robotcar/status";

const int LEFT_PWM_PIN = 25;
const int LEFT_DIR_PIN = 26;
const int RIGHT_PWM_PIN = 27;
const int RIGHT_DIR_PIN = 33;
const uint8_t DRIVE_SPEED = 210;
const unsigned long COMMAND_TIMEOUT_MS = 1000;
const unsigned long MQTT_RETRY_MS = 5000;

WebServer server(80);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
unsigned long lastCommandMs = 0;
unsigned long lastMqttAttemptMs = 0;
bool moving = false;

void setMotor(int pwmPin, int directionPin, bool forward, uint8_t speed) {
  digitalWrite(directionPin, forward ? LOW : HIGH);
  analogWrite(pwmPin, speed);
}

void stopMotors() {
  analogWrite(LEFT_PWM_PIN, 0);
  analogWrite(RIGHT_PWM_PIN, 0);
  moving = false;
}

void driveForward() {
  setMotor(LEFT_PWM_PIN, LEFT_DIR_PIN, true, DRIVE_SPEED);
  setMotor(RIGHT_PWM_PIN, RIGHT_DIR_PIN, true, DRIVE_SPEED);
  moving = true;
}

void driveBackward() {
  setMotor(LEFT_PWM_PIN, LEFT_DIR_PIN, false, DRIVE_SPEED);
  setMotor(RIGHT_PWM_PIN, RIGHT_DIR_PIN, false, DRIVE_SPEED);
  moving = true;
}

void turnLeft() {
  setMotor(LEFT_PWM_PIN, LEFT_DIR_PIN, false, DRIVE_SPEED);
  setMotor(RIGHT_PWM_PIN, RIGHT_DIR_PIN, true, DRIVE_SPEED);
  moving = true;
}

void turnRight() {
  setMotor(LEFT_PWM_PIN, LEFT_DIR_PIN, true, DRIVE_SPEED);
  setMotor(RIGHT_PWM_PIN, RIGHT_DIR_PIN, false, DRIVE_SPEED);
  moving = true;
}

bool processCommand(String command) {
  command.trim();
  command.toLowerCase();
  if (command == "forward") {
    driveForward();
  } else if (command == "back" || command == "backward") {
    driveBackward();
  } else if (command == "left") {
    turnLeft();
  } else if (command == "right") {
    turnRight();
  } else if (command == "stop") {
    stopMotors();
  } else {
    return false;
  }
  lastCommandMs = millis();
  return true;
}

void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String command;
  for (unsigned int i = 0; i < length; ++i) {
    command += static_cast<char>(payload[i]);
  }
  if (processCommand(command)) {
    mqtt.publish(MQTT_STATUS_TOPIC, command.c_str());
  }
}

void startLocalControlPage() {
  WiFi.mode(WIFI_AP);
  WiFi.softAP("RobotCar-Control", "robotcar123");
  server.on("/", HTTP_GET, []() {
    server.send(200, "text/html", "<h1>Robot car control</h1><p>Use /cmd?move=forward, backward, left, right, or stop.</p>");
  });
  server.on("/cmd", HTTP_GET, []() {
    if (!server.hasArg("move")) {
      server.send(400, "text/plain", "Add move=forward, backward, left, right, or stop");
      return;
    }
    String command = server.arg("move");
    if (processCommand(command)) {
      server.send(200, "text/plain", "Command accepted: " + command);
    } else {
      server.send(400, "text/plain", "Unknown command");
    }
  });
  server.begin();
}

void connectToWifi() {
  if (strlen(WIFI_SSID) == 0) {
    startLocalControlPage();
    return;
  }
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  unsigned long startMs = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - startMs < 15000) {
    delay(250);
  }
  if (WiFi.status() != WL_CONNECTED) {
    startLocalControlPage();
  }
}

void reconnectMqttIfNeeded() {
  if (WiFi.status() != WL_CONNECTED || mqtt.connected()) {
    return;
  }
  if (millis() - lastMqttAttemptMs < MQTT_RETRY_MS) {
    return;
  }
  lastMqttAttemptMs = millis();
  String clientId = "schematik-car-" + String(static_cast<uint32_t>(ESP.getEfuseMac()), HEX);
  if (mqtt.connect(clientId.c_str())) {
    mqtt.subscribe(MQTT_COMMAND_TOPIC);
    mqtt.publish(MQTT_STATUS_TOPIC, "online");
  }
}

void setup() {
  pinMode(LEFT_DIR_PIN, OUTPUT);
  pinMode(RIGHT_DIR_PIN, OUTPUT);
  pinMode(LEFT_PWM_PIN, OUTPUT);
  pinMode(RIGHT_PWM_PIN, OUTPUT);
  stopMotors();
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  mqtt.setCallback(mqttCallback);
  connectToWifi();
}

void loop() {
  server.handleClient();
  reconnectMqttIfNeeded();
  mqtt.loop();
  if (moving && millis() - lastCommandMs >= COMMAND_TIMEOUT_MS) {
    stopMotors();
    if (mqtt.connected()) {
      mqtt.publish(MQTT_STATUS_TOPIC, "stopped: command timeout");
    }
  }
  delay(10);
}