Skip to Content

Wi-Fi SMART HOME CONTROLLER

Smart home controllers have become an essential part of modern households, providing efficient and reliable ways to manage and automate various appliances. This Wi‑Fi Smart Home Controller project is meticulously designed to offer seamless integration of everyday devices into a centralized control system. By harnessing the robust wireless capabilities of the ESP32 microcontroller and coupling it with a carefully chosen relay module, this controller enables precise management of high‑power devices such as lights, fans, and more.

The system is built to communicate over your home network, ensuring that commands sent from a dedicated smartphone application are executed promptly and accurately. This remote control capability means you can easily monitor and adjust your appliances from anywhere, whether you’re at home or on the go. 

The project emphasizes both user-friendliness and technical reliability, making it suitable for anyone interested in enhancing their home automation setup. Through clear instructions and a well-organized code structure, even beginners can confidently embark on this journey toward a smarter, more connected living environment.

Components Required

  • ESP32 Development Board
  • Relay Module (2‑channel or 4‑channel, depending on your needs)
  • USB Cable for programming and power
  • Jumper Wires
  • Breadboard (optional for prototyping)
  • External 5V Power Supply (for the relay module if necessary)
  • Smartphone with a compatible control app or web browser

Circuit Diagram

Component Connections

1. Connecting the ESP32 to the Relay Module
The relay module serves as the bridge between the low‑power ESP32 and your high‑power household appliances. The ESP32’s digital pins send control signals to the relay module, which in turn toggles the appliances on and off.

Wiring the Relay Module to the ESP32

  • VCC (Relay Module Power): Connect to an external 5V supply (if the module requires 5V).
  • GND (Common Ground): Connect to the GND pin on the ESP32 and the external power supply’s ground.
  • IN1 (Control Pin for Relay 1): Connect to a designated digital output pin on the ESP32 (e.g., D5).
  • IN2 (Control Pin for Relay 2): Connect to another digital output pin on the ESP32 (e.g., D18).

These connections enable the ESP32 to send digital signals that activate or deactivate the relays, effectively controlling the connected appliances.

2. Integrating Wi‑Fi Connectivity
The ESP32’s built‑in Wi‑Fi module allows it to join your home network, where it can receive commands from your smartphone app. Through simple HTTP requests or an MQTT broker, the ESP32 can interpret incoming instructions and adjust the state of the relay outputs accordingly.

Powering the System

  • ESP32: Power the microcontroller via a USB cable connected to a computer or a dedicated power adapter.
  • Relay Module: If required, use an external 5V power source. Ensure that the grounds of both the ESP32 and the relay module are connected together for a stable operation.

3. Installing the Components

  • Secure the ESP32 on a mounting board or inside a project enclosure.
  • Fasten the relay module in a location that provides easy access to the appliances it controls.
  • Use jumper wires to make secure and reliable connections between the ESP32 and the relay module.

4. Uploading the Code to the ESP32

  • Open the Arduino IDE on your computer.
  • Create a new sketch and paste the code provided below.
  • Select the appropriate board (ESP32) and the correct COM port.
  • Click the Upload button to program the ESP32.
    Once the code is successfully uploaded, the ESP32 will connect to your Wi‑Fi network and start listening for commands from your smartphone.

CODE

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

// Replace with your network credentials
const char* ssid = "Your_SSID";
const char* password = "Your_PASSWORD";

WebServer server(80);

// Define relay control pins
const int relayPin1 = 5;
const int relayPin2 = 18;

// Function to handle the root URL
void handleRoot() {
  server.send(200, "text/html", 
    "<h1>Wi-Fi Smart Home Controller</h1>"
    "<p>Visit /on or /off to control your appliance.</p>"
  );
}

// Function to turn the appliance on
void handleOn() {
  digitalWrite(relayPin1, LOW); // LOW may activate the relay depending on the module
  server.send(200, "text/html", "<p>Appliance turned ON</p>");
}

// Function to turn the appliance off
void handleOff() {
  digitalWrite(relayPin1, HIGH);
  server.send(200, "text/html", "<p>Appliance turned OFF</p>");
}

void setup() {
  Serial.begin(115200);
  
  // Initialize relay control pins
  pinMode(relayPin1, OUTPUT);
  pinMode(relayPin2, OUTPUT);
  digitalWrite(relayPin1, HIGH); // Ensure the relay is off at startup
  digitalWrite(relayPin2, HIGH);

  // Connect to Wi-Fi network
  WiFi.begin(ssid, password);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected to Wi-Fi");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());

  // Define URL routes and their corresponding handler functions
  server.on("/", handleRoot);
  server.on("/on", handleOn);
  server.on("/off", handleOff);
  server.begin();
  Serial.println("HTTP server started");
}

void loop() {
  server.handleClient();
}


CODE EXPLANATION

1. Including Libraries and Declaring Global Variables

#include <WiFi.h>
#include <WebServer.h>
  • #include <WiFi.h>: This line brings in the Wi‑Fi library, which allows the ESP32 to connect to a wireless network.
  • #include <WebServer.h>: This line includes the WebServer library, which lets the ESP32 run a simple web server to handle HTTP requests.
// Replace with your network credentials
const char* ssid = "Your_SSID";
const char* password = "Your_PASSWORD";
  • Network Credentials: Here, you define two constant character pointers that store your Wi‑Fi network name (SSID) and password. These are used later to connect the ESP32 to your home network.
WebServer server(80);
  • Web Server Initialization: This creates a server object that listens on port 80—the default port for HTTP traffic. This object will handle incoming web requests.
// Define relay control pins
const int relayPin1 = 5;
const int relayPin2 = 18;
  • Relay Control Pins: These lines define which pins on the ESP32 will control the relay module. The pins are set as constants so that you can easily refer to them throughout your code.

2. Creating HTTP Request Handler Functions

// Function to handle the root URL
void handleRoot() {
  server.send(200, "text/html", 
    "<h1>Wi-Fi Smart Home Controller</h1>"
    "<p>Visit /on or /off to control your appliance.</p>"
  );
}
  • handleRoot() Function:
    • This function is called when someone accesses the main page ("/") of your server.
    • server.send(200, "text/html", ...) sends a response with an HTTP status code 200 (OK) and returns a simple HTML page that tells the user to visit /on or /off to control the appliance.
// Function to turn the appliance on
void handleOn() {
  digitalWrite(relayPin1, LOW); // LOW may activate the relay depending on the module
  server.send(200, "text/html", "<p>Appliance turned ON</p>");
}
  • handleOn() Function:
    • This function is triggered when someone visits the /on URL.
    • digitalWrite(relayPin1, LOW); sends a LOW signal to the relay, which typically activates it (check your relay's specifications as some modules use LOW for activation).
    • It then sends an HTML response confirming that the appliance has been turned on.
// Function to turn the appliance off
void handleOff() {
  digitalWrite(relayPin1, HIGH);
  server.send(200, "text/html", "<p>Appliance turned OFF</p>");
}
  • handleOff() Function:
    • This function is activated when the /off URL is accessed.
    • digitalWrite(relayPin1, HIGH); sets the relay control pin to HIGH, which usually deactivates the relay.
    • An HTML response is sent to let the user know that the appliance has been turned off.

3.The Setup Function

void setup() {
  Serial.begin(115200);
  • Serial Communication:
    • Serial.begin(115200); starts serial communication at a baud rate of 115200. This allows you to see messages on your computer’s Serial Monitor, which is useful for debugging.
// Initialize relay control pins
  pinMode(relayPin1, OUTPUT);
  pinMode(relayPin2, OUTPUT);
  digitalWrite(relayPin1, HIGH); // Ensure the relay is off at startup
  digitalWrite(relayPin2, HIGH);
  • Setting Up Relay Pins:
    • pinMode(relayPin1, OUTPUT); and pinMode(relayPin2, OUTPUT); configure the relay pins as outputs so that the ESP32 can control them.
    • digitalWrite(relayPin1, HIGH); and similarly for relayPin2 set the initial state of the relay pins to HIGH, ensuring that the relay is off when the device starts.
 // Connect to Wi-Fi network
  WiFi.begin(ssid, password);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected to Wi-Fi");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());
  • Connecting to Wi‑Fi:
    • WiFi.begin(ssid, password); attempts to connect the ESP32 to the specified Wi‑Fi network using the credentials provided earlier.
    • The while loop checks if the connection is established by repeatedly testing WiFi.status(). Until the connection is made, the code waits 500 milliseconds and prints a dot (".") to show progress.
    • Once connected, the ESP32 prints "Connected to Wi‑Fi" along with its IP address, which you will need to access the web server.
// Define URL routes and their corresponding handler functions
  server.on("/", handleRoot);
  server.on("/on", handleOn);
  server.on("/off", handleOff);
  server.begin();
  Serial.println("HTTP server started");
}
  • Setting Up the Web Server:
    • server.on("/", handleRoot); assigns the handleRoot() function to handle requests at the root URL ("/").
    • server.on("/on", handleOn); and server.on("/off", handleOff); do the same for the /on and /off endpoints.
    • server.begin(); starts the web server so that it begins listening for incoming HTTP requests.
    • A confirmation message "HTTP server started" is printed to the Serial Monitor.

4. The Loop Function

void loop() {
  server.handleClient();
}
  • Handling Incoming Requests:
    • The loop() function runs continuously after setup() has finished.
    • server.handleClient(); checks if any client (like your smartphone or computer) has sent an HTTP request. If there is a request, it processes the request by calling the appropriate handler function (for example, handleOn() or handleOff()).

How It Works Together

When you compile and upload this code to your ESP32:

  • The device initializes its serial communication and sets up the relay pins.
  • It then connects to your Wi‑Fi network using the credentials provided.
  • Once connected, it starts the web server, waiting for requests on port 80.
  • When you access the ESP32’s IP address in a browser, the root URL ("/") displays instructions.
  • Navigating to /on or /off sends commands to the ESP32, which then toggles the relay, thereby controlling the connected appliance.

All these components—Wi‑Fi connectivity, a running web server, and relay control—work together to allow you to remotely manage home appliances.

OBSERVING FUNCTIONALITY

When the system is up and running:

  • Initial Connection:
    The Serial Monitor will display a series of dots until the ESP32 connects to Wi‑Fi, after which it will print the assigned IP address.
  • Accessing the Web Interface:
    Enter the printed IP address into a web browser. The root page will show a simple message directing you to use /on or /off for control.
  • Controlling the Appliance:
    • Visiting the /on URL turns the appliance on, which you can confirm by the returned HTML message.
    • Visiting the /off URL turns the appliance off, with a similar confirmation message.
  • Real-Time Response:Each command you send via the browser is processed immediately by the ESP32, demonstrating the real-time control of your home appliance through the web interface.

COMMON PROBLEMS AND SOLUTIONS

Wi‑Fi Connection Issues:

  • Cause: Incorrect SSID or password, or poor network coverage.
  • Solution: Verify your network credentials and ensure the ESP32 is within a strong signal range.

Relay Not Activating:

  • Cause: Wiring errors or a mismatch in voltage requirements.
  • Solution: Double-check the connections between the ESP32 and the relay module, and confirm that the relay module is receiving the proper voltage.

Smartphone App Communication Failure:

  • Cause: Incorrect URL or network configuration issues.
  • Solution: Ensure the IP address displayed on the Serial Monitor is used in your app or browser, and verify that your device is on the same network as the ESP32.

Conclusion

The Wi‑Fi Smart Home Controller offers an elegant solution for managing your home appliances remotely. By harnessing the ESP32’s integrated Wi‑Fi capabilities alongside a relay module, the system enables seamless and efficient control via a smartphone application. This project not only simplifies the automation of household devices but also exemplifies how modern microcontrollers can be integrated into practical, everyday applications.

Comments

COLOUR-TRIGGERED ALARM