Makers Smart Home Kit: 10 Practical ESP8266 Projects for Smart Home Automation

Contents List

1. Introduction
2. What Is the Makers Smart Home Kit?
3. Why Use ESP8266 for Smart Home Projects?
4. Main Components of the Kit
5. ESP8266 NodeMCU and Pin Planning
6. Project 01 — Automatic Night Light
7. Project 02 — Motion Activated Light
8. Project 03 — Door Open Alarm
9. Project 04 — Security Motion Alarm
10. Project 05 — Automatic Fan Controller
11. Project 06 — Electronic Door Lock
12. Project 07 — Password Door Lock
13. Project 08 — Smart Room Controller
14. Project 09 — Home Security System
15. Project 10 — Complete Smart Home
16. Programming and Wi-Fi Connectivity
17. Safety and Design Considerations
18. Frequently Asked Questions
19. Conclusion

Time reading is 20min.

1. Introduction

Smart home technology combines sensors, controllers, actuators, and wireless communication to automate everyday tasks and monitor the home environment.

The Makers Smart Home Kit is designed as a practical learning platform based on the ESP8266 NodeMCU 30-Pin with CP2102 Micro USB. Instead of providing components for only one experiment, the kit allows beginners, hobbyists, and engineers to build a series of progressively more advanced smart-home projects using the same main controller.

The projects start with simple circuits such as an automatic night light and gradually introduce motion detection, alarms, temperature-based control, servo-operated locks, password protection, multiple sensors, relays, displays, and Wi-Fi connectivity.

The ESP8266 is particularly relevant to this type of project because it combines a microcontroller with 2.4 GHz Wi-Fi and interfaces such as GPIO, UART, SPI, I²C, PWM, and ADC. Espressif lists home appliances, home automation, smart lights, smart plugs, sensor networks, and security-related applications among ESP8266EX applications.

This makes the kit useful not only for learning individual electronic components, but also for understanding how a complete IoT-based automation system is designed.

 What You Will Learn?

By completing the ten projects, the learner can gradually understand:

• Digital and analog sensors
• GPIO input and output
• Automatic lighting
• Motion detection
• Door and window monitoring
• Buzzer-based alarms
• Temperature-based control
• Relay operation
• Servo motor control
• Keypad input
• LCD/OLED displays
• Sensor combination and automation logic
• Wi-Fi communication
• Basic IoT concepts
• Complete smart-home system architecture

2. What Is the Makers Smart Home Kit?

The Makers Smart Home Kit is a reusable electronics development platform centered around an ESP8266 NodeMCU development board.

The basic idea is simple:   Sense → Process → Decide → Act → Communicate

• A sensor first detects a physical condition. The ESP8266 processes the information and applies the programmed logic.
• It then controls an output such as an LED, buzzer, relay, servo, or display.
• When Wi-Fi is included, the ESP8266 can also communicate with a local network or an Internet-based service.

For example:   PIR Sensor → ESP8266 → Relay → Light

• The PIR detects movement, the ESP8266 decides whether the light should be switched on, and the relay controls the low-voltage load.
• This same principle can be expanded into a complete smart-home system.

3. Why Use ESP8266 for Smart Home Projects?

Built-In Wi-Fi

• One of the main advantages of the ESP8266 is that Wi-Fi is integrated into the SoC rather than requiring a separate Wi-Fi shield.
• The ESP8266EX supports IEEE 802.11 b/g/n operation in the 2.4 GHz band and can operate as a station or access point.
• For a smart-home learning kit, this means the same controller can be used for both local electronics experiments and network-connected projects.

Multiple Digital Interfaces

• The ESP8266 provides GPIO pins that can be used for switches, PIR sensors, LEDs, buzzers, relay modules, servo control, and other digital devices.
• It also supports interfaces including I²C, SPI, UART, and PWM.

Analog Input

• The ESP8266 has one user-accessible ADC channel.
• This is important when planning the kit because an LDR or another analog sensor can use A0, but the design should not depend on many simultaneous analog inputs.
• For this reason, the Makers Smart Home Kit should favor digital sensors and I²C devices where possible.

Suitable for Learning IoT

The ESP8266 Arduino Core provides support for Arduino-style programming and libraries for Wi-Fi, I²C, SPI, interrupts, digital I/O, and analog input.

This gives beginners a relatively straightforward path from:

Blinking an LED

to:  Building a Wi-Fi-connected smart-home controller.

4. Main Components of the Kit

A practical version of the Makers Smart Home Kit can contain the following components.

The DHT22 is a digital temperature/humidity sensor containing a humidity sensing element, thermistor, and internal conversion electronics, making it convenient for beginner microcontroller projects.

5. ESP8266 NodeMCU and Pin Planning

• Good pin planning is particularly important with ESP8266 because not every GPIO should be treated as an unrestricted general-purpose pin.
• The ESP8266 uses GPIO0, GPIO2, and GPIO15 during startup to select its boot mode.
• Consequently, connecting sensors or modules to these pins without considering their startup states can cause boot problems.
• A practical arrangement for the Makers kit can therefore reserve the pins carefully.

Suggested Pin Assignment

* D3/GPIO0 and D4/GPIO2 require additional care because they are boot-strapping pins.

• For a production kit, the exact pin allocation should be validated against the specific NodeMCU board and the attached module’s startup behavior.
• GPIO0, GPIO2, and GPIO15 participate in ESP8266 boot-mode selection.
• For the final hardware design, it is preferable to reserve the boot-sensitive pins or isolate them appropriately rather than treating them like ordinary GPIOs.

I²C Display

An I²C display is especially useful because it requires only the two I²C signal lines plus power and ground.

For an I²C OLED:

• ESP8266 SDA → OLED SDA
• ESP8266 SCL → OLED SCL
• 3.3 V → OLED VCC
• GND → OLED GND

I²C OLED modules such as SSD1306-based displays are commonly used with microcontrollers through their SDA and SCL connections.

6. Project 01 — Automatic Night Light

The first project introduces one of the simplest smart-home concepts: automatically controlling a light according to the surrounding brightness.

Components

• ESP8266 NodeMCU
• LDR
• Resistor
• LED
• Breadboard
• Jumper wires

How It Works?

• The LDR changes its resistance according to the amount of light falling on it.
• A voltage-divider circuit converts this resistance change into a voltage that can be measured by the ESP8266 ADC.

The basic operation is:

• Light detected → LED OFF
• Darkness detected → LED ON

The software continuously reads A0 and compares the measured value with a programmed threshold.

Why This Project Is Important

• This simple circuit introduces the relationship between:  Physical condition → Sensor → Microcontroller → Decision → Output
• The same concept is used in larger lighting-control systems.

Important ESP8266 Consideration

Because the ESP8266 has only one user ADC channel, the LDR should normally be treated as the primary analog sensor in this kit.

Connections

Arduino IDE Code

const int LDR_PIN = A0;
const int LED_PIN = D6;

// Adjust this value after testing your LDR circuit.
const int LIGHT_THRESHOLD = 500;

void setup() {
  Serial.begin(115200);

  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  Serial.println("Automatic Night Light");
}

void loop() {
  int lightValue = analogRead(LDR_PIN);

  Serial.print("LDR Value: ");
  Serial.println(lightValue);

  // Adjust this comparison according to your voltage-divider orientation.
  if (lightValue < LIGHT_THRESHOLD) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }

  delay(200);
}

Programming Explanation

The ESP8266 reads the LDR through its single analog input, A0.

The program compares the reading with LIGHT_THRESHOLD.

When the measured value indicates darkness, the LED is switched on.

The threshold is not universal. It should be calibrated experimentally with the actual LDR and resistor used in the kit.

7. Project 02 — Motion Activated Light

The second project replaces the light sensor with a motion sensor.

Components

• ESP8266 NodeMCU
• PIR motion sensor
• LED
• Resistor

How It Works?

• A PIR sensor detects changes in infrared radiation associated with moving people or objects.
• The ESP8266 reads the PIR’s digital output.
• When motion is detected:  PIR → ESP8266 → LED ON
• After a programmed delay:  LED → OFF

Example Logic

Start
  ↓
Read PIR
  ↓
Motion detected?
  ├── No → Keep LED OFF
  └── Yes
       ↓
     LED ON
       ↓
    Wait period
       ↓
     LED OFF

This project introduces timers and event-based automation.

Connections

Arduino IDE Code

const int PIR_PIN = D5;
const int LED_PIN = D6;

const unsigned long LIGHT_ON_TIME = 10000; // 10 seconds

unsigned long motionTime = 0;
bool lightOn = false;

void setup() {
  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);

  digitalWrite(LED_PIN, LOW);

  Serial.println("Motion Activated Light");
}

void loop() {
  int motionState = digitalRead(PIR_PIN);

  if (motionState == HIGH) {
    digitalWrite(LED_PIN, HIGH);

    lightOn = true;
    motionTime = millis();

    Serial.println("Motion detected");
  }

  if (lightOn && (millis() - motionTime >= LIGHT_ON_TIME)) {
    digitalWrite(LED_PIN, LOW);
    lightOn = false;

    Serial.println("Light OFF");
  }
}

Programming Explanation

• The PIR output is read as a digital signal.
• When the PIR becomes HIGH, the ESP8266 turns the LED on and records the current millis() value.
• Using millis() instead of delay() allows the ESP8266 to continue executing other tasks while the light timer is running.

8. Project 03 — Door Open Alarm

This project demonstrates how a smart-home system can monitor a door or window.

Components

• ESP8266 NodeMCU
• Magnetic reed switch
• Magnet
• Buzzer
• Optional LED

How It Works?

• The reed switch changes state when the magnet moves close to or away from it.
• The magnet is attached to the moving door while the reed switch is fixed to the door frame.
• When the door opens:  Magnet moves away → Reed switch changes state → ESP8266 detects opening → Buzzer activates

Practical Application

The same principle can be used for:

• Doors
• Windows
• Cabinets
• Drawers
• Storage boxes

This makes the project a useful introduction to basic intrusion detection.

Connections

The example uses the ESP8266’s internal pull-up resistor.

Arduino IDE Code

const int REED_PIN = D7;
const int BUZZER_PIN = D0;

void setup() {
  Serial.begin(115200);

  pinMode(REED_PIN, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);

  digitalWrite(BUZZER_PIN, LOW);

  Serial.println("Door Open Alarm");
}

void loop() {

  int doorState = digitalRead(REED_PIN);

  // LOW = door closed
  // HIGH = door open
  if (doorState == HIGH) {

    digitalWrite(BUZZER_PIN, HIGH);

    Serial.println("WARNING: Door Open");
  }
  else {

    digitalWrite(BUZZER_PIN, LOW);

    Serial.println("Door Closed");
  }

  delay(100);
}

Important

• The actual logic depends on how the reed switch is physically installed.
• If your reed switch behaves in the opposite direction, simply reverse the HIGH and LOW conditions.

9. Project 04 — Security Motion Alarm

The fourth project changes the output from a simple indicator to an alarm.

Components

• ESP8266 NodeMCU
• PIR sensor
• Buzzer
• LED

Operation

• The PIR monitors the protected area.
• When movement is detected:  PIR → ESP8266 → Buzzer + LED
• The software can keep the alarm active for a predetermined period.
• A push button can also be added as an alarm-reset input.

What the Learner Understands?

• This project introduces the idea that a sensor does not directly control the final device.
• Instead:   Sensor → Controller → Decision → Actuator
• The ESP8266 provides the decision-making layer.

Connections

Arduino IDE Code

const int PIR_PIN = D5;
const int BUZZER_PIN = D0;
const int LED_PIN = D6;

const unsigned long ALARM_TIME = 10000; // 10 seconds

bool alarmActive = false;
unsigned long alarmStartTime = 0;

void setup() {
  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);

  digitalWrite(BUZZER_PIN, LOW);
  digitalWrite(LED_PIN, LOW);

  Serial.println("Security Motion Alarm");
}

void loop() {

  int motion = digitalRead(PIR_PIN);

  if (motion == HIGH && !alarmActive) {

    alarmActive = true;
    alarmStartTime = millis();

    Serial.println("MOTION DETECTED!");
  }

  if (alarmActive) {

    digitalWrite(BUZZER_PIN, HIGH);
    digitalWrite(LED_PIN, HIGH);

    if (millis() - alarmStartTime >= ALARM_TIME) {

      digitalWrite(BUZZER_PIN, LOW);
      digitalWrite(LED_PIN, LOW);

      alarmActive = false;

      Serial.println("Alarm Reset");
    }
  }
}

Programming Concept

The important new concept is the system state:

NORMAL
   ↓
Motion detected
   ↓
ALARM ACTIVE
   ↓
Timeout
   ↓
NORMAL

10. Project 05 — Automatic Fan Controller

This project introduces temperature-based automation.

Components

• ESP8266 NodeMCU
• DHT22 temperature/humidity sensor
• Relay module
• Low-voltage DC fan

The DHT22 provides digital temperature and humidity information to the ESP8266.

How It Works?

The ESP8266 reads the room temperature periodically.

For example:

• Temperature < 28°C → Fan OFF
• Temperature ≥ 30°C → Fan ON

Using two different thresholds creates hysteresis and helps prevent rapid relay switching around a single threshold.

Why Use a Relay?

• The ESP8266 GPIO should not be used to power a fan directly.
• The relay provides an electrically controlled switching interface between the controller and the load.
• For a beginner-oriented kit, a low-voltage DC fan is preferable to a mains-powered fan.
• For this project I recommend using a DHT22 and a low-voltage DC fan controlled through a relay module.

Required Library

• Install:  DHT sensor library by Adafruit
• and its dependency:  Adafruit Unified Sensor

Connections

Arduino IDE Code

#include <DHT.h>

#define DHT_PIN D5
#define DHT_TYPE DHT22

const int RELAY_PIN = D6;

const float FAN_ON_TEMP = 30.0;
const float FAN_OFF_TEMP = 28.0;

DHT dht(DHT_PIN, DHT_TYPE);

bool fanState = false;

void setup() {
  Serial.begin(115200);

  dht.begin();

  pinMode(RELAY_PIN, OUTPUT);

  // Change these if your relay is active HIGH.
  digitalWrite(RELAY_PIN, HIGH);

  Serial.println("Automatic Fan Controller");
}

void loop() {

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  if (isnan(temperature) || isnan(humidity)) {

    Serial.println("DHT22 reading failed");
    delay(2000);

    return;
  }

  Serial.print("Temperature: ");
  Serial.print(temperature);
  Serial.println(" C");

  Serial.print("Humidity: ");
  Serial.print(humidity);
  Serial.println(" %");

  // Hysteresis control
  if (!fanState && temperature >= FAN_ON_TEMP) {

    fanState = true;

    digitalWrite(RELAY_PIN, LOW);

    Serial.println("Fan ON");
  }

  if (fanState && temperature <= FAN_OFF_TEMP) {

    fanState = false;

    digitalWrite(RELAY_PIN, HIGH);

    Serial.println("Fan OFF");
  }

  delay(2000);
}

Why Two Temperatures?

Using:

• Fan ON = 30°C
• Fan OFF = 28°C

prevents the relay from rapidly switching when the temperature is hovering around 30°C.

This is called hysteresis.

11. Project 06 — Electronic Door Lock

This project introduces servo motor control.

Components

• ESP8266 NodeMCU
• Push button
• SG90 servo
• LED
• Optional buzzer

How It Works?

• The push button acts as a simple authorization input.
• For example:  Button pressed → ESP8266 verifies input → Servo moves to unlock position
• After a delay:  Servo returns to locked position
• The servo therefore represents a small electronic locking mechanism.

Learning Objective

This project teaches:

• Digital input
• Servo control
• Timing
• State changes
• Simple access-control logic

Connections

Required Library

The ESP8266 Arduino core includes the Servo functionality.

Arduino IDE Code

#include <Servo.h>

const int BUTTON_PIN = D7;
const int SERVO_PIN = D4;

const int LOCK_POSITION = 0;
const int UNLOCK_POSITION = 90;

Servo doorServo;

void setup() {
  Serial.begin(115200);

  pinMode(BUTTON_PIN, INPUT_PULLUP);

  doorServo.attach(SERVO_PIN);

  doorServo.write(LOCK_POSITION);

  Serial.println("Electronic Door Lock");
}

void loop() {

  int buttonState = digitalRead(BUTTON_PIN);

  if (buttonState == LOW) {

    Serial.println("Unlocking...");

    doorServo.write(UNLOCK_POSITION);

    delay(3000);

    Serial.println("Locking...");

    doorServo.write(LOCK_POSITION);

    // Prevent repeated triggering
    delay(500);
  }
}

Important Servo Power Note

• Do not assume the ESP8266 board’s 3.3 V pin should power the servo.
• A small servo can create significant current transients.
• Use an appropriate external supply for the servo and connect its GND to the ESP8266 GND.

12. Project 07 — Password Door Lock

The next step is to replace the simple push button with a keypad.

Components

• ESP8266 NodeMCU
• 4×4 keypad
• SG90 servo
• I²C LCD
• Buzzer

Basic Operation

• The LCD displays:   Enter Password
• The user enters a sequence through the keypad.
• The ESP8266 compares the entered sequence with the programmed password.

Correct Password

Enter password
      ↓
Compare
      ↓
Correct
      ↓
Servo UNLOCK
      ↓
Delay
      ↓
Servo LOCK

Incorrect Password

Enter password
      ↓
Compare
      ↓
Incorrect
      ↓
Buzzer
      ↓
Access Denied

• The LCD provides immediate feedback to the user.
• This project introduces a basic form of embedded access control.

Components

• ESP8266 NodeMCU
• 4×4 keypad
• SG90 servo
• I²C LCD
• Buzzer

Important Pin Planning

• A 4×4 keypad requires 8 GPIO lines, while the LCD uses two I²C lines and the servo/buzzer require additional outputs.
• Therefore, I recommend using a 4×3 keypad for the compact version of the kit, or using an I/O expander such as the PCF8574 if the kit specifically requires a 4×4 keypad.
• The following example uses a 4×3 keypad.

Example Connections

Arduino IDE Code

#include <Keypad.h>
#include <Servo.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

const byte ROWS = 4;
const byte COLS = 3;

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

byte rowPins[ROWS] = {D1, D2, D5, D6};
byte colPins[COLS] = {D7, D8, D0};

Keypad keypad = Keypad(
  makeKeymap(keys),
  rowPins,
  colPins,
  ROWS,
  COLS
);

LiquidCrystal_I2C lcd(0x27, 16, 2);

Servo doorServo;

const int SERVO_PIN = D4;
const int BUZZER_PIN = D3;

const int LOCK_POSITION = 0;
const int UNLOCK_POSITION = 90;

const char PASSWORD[] = "1234";

String enteredPassword = "";

void setup() {

  Serial.begin(115200);

  pinMode(BUZZER_PIN, OUTPUT);

  doorServo.attach(SERVO_PIN);
  doorServo.write(LOCK_POSITION);

  lcd.init();
  lcd.backlight();

  lcd.setCursor(0, 0);
  lcd.print("Enter Password");

  lcd.setCursor(0, 1);
}

void loop() {

  char key = keypad.getKey();

  if (key == NO_KEY) {
    return;
  }

  if (key == '#') {

    checkPassword();

    return;
  }

  if (key == '*') {

    enteredPassword = "";

    lcd.clear();
    lcd.print("Password Clear");

    delay(1000);

    showPasswordPrompt();

    return;
  }

  if (enteredPassword.length() < 8) {

    enteredPassword += key;

    lcd.setCursor(enteredPassword.length() - 1, 1);
    lcd.print('*');
  }
}

void checkPassword() {

  if (enteredPassword == PASSWORD) {

    lcd.clear();
    lcd.print("Access Granted");

    Serial.println("Correct Password");

    doorServo.write(UNLOCK_POSITION);

    delay(3000);

    doorServo.write(LOCK_POSITION);

  } else {

    lcd.clear();
    lcd.print("Access Denied");

    Serial.println("Incorrect Password");

    digitalWrite(BUZZER_PIN, HIGH);
    delay(1000);
    digitalWrite(BUZZER_PIN, LOW);
  }

  enteredPassword = "";

  delay(1000);

  showPasswordPrompt();
}

void showPasswordPrompt() {

  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.print("Enter Password");

  lcd.setCursor(0, 1);
}

Important

The exact LCD library and keypad pin allocation should be finalized according to the actual modules included in the Makers kit.

13. Project 08 — Smart Room Controller

This project combines multiple sensors into one automation system.

Components

• ESP8266 NodeMCU
• LDR
• PIR
• Relay
• LED or low-voltage lamp

Operating Principle

The system uses both brightness and motion.

For example:

• Room is dark + motion detected → Light ON
• Room is bright → Light OFF

No motion for a defined period → Light OFF

Instead of reacting to only one sensor, the ESP8266 combines multiple conditions.

Example Decision Logic

              ┌── Room bright ──→ Light OFF
              │
LDR ──────────┤
              │
              └── Room dark
                       │
                       ▼
                     Check PIR
                       │
             ┌─────────┴─────────┐
             │                   │
       Motion detected      No motion
             │                   │
             ▼                   ▼
         Light ON          Light OFF

This is an important transition from individual experiments to real automation logic.

Connections

Arduino IDE Code

const int LDR_PIN = A0;
const int PIR_PIN = D5;
const int RELAY_PIN = D6;

const int DARK_THRESHOLD = 500;

const unsigned long LIGHT_TIMEOUT = 30000;

unsigned long lastMotionTime = 0;

bool lightState = false;

void setup() {

  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);

  // Relay OFF for an active-low module
  digitalWrite(RELAY_PIN, HIGH);

  Serial.println("Smart Room Controller");
}

void loop() {

  int lightValue = analogRead(LDR_PIN);
  int motion = digitalRead(PIR_PIN);

  bool dark = lightValue < DARK_THRESHOLD;

  if (motion == HIGH) {

    lastMotionTime = millis();

    Serial.println("Motion detected");
  }

  if (dark && (millis() - lastMotionTime < LIGHT_TIMEOUT)) {

    if (!lightState) {

      digitalWrite(RELAY_PIN, LOW);
      lightState = true;

      Serial.println("Room Light ON");
    }

  } else {

    if (lightState) {

      digitalWrite(RELAY_PIN, HIGH);
      lightState = false;

      Serial.println("Room Light OFF");
    }
  }

  delay(100);
}

Programming Concept

This project makes a decision using two different inputs:

Dark?
  +
Motion recently detected?
  ↓
Light ON

This is much closer to real smart-home automation than simply connecting one sensor to one output.

14. Project 09 — Home Security System

This project combines two different types of security sensors.

Components

• ESP8266 NodeMCU
• Reed switch
• PIR sensor
• Buzzer
• LCD
• Optional LED

Sensor Roles

• Reed switch: monitors doors and windows.
• PIR: monitors movement.
• Buzzer: provides an audible alarm.
• LCD: displays the security status.

Example System

When the system is armed:  Door opens → Alarm  or   Motion detected → Alarm

The LCD can display:

• System Armed
• System Disarmed
• Door Open
• Motion Detected
• Alarm Active

Why This Project Is Different

• The system now has several inputs and several possible events.
• The ESP8266 must determine which sensor generated the event and select the appropriate response.
• This introduces the concept of a small embedded state machine.

Connections

Arduino IDE Code

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

const int REED_PIN = D7;
const int PIR_PIN = D5;
const int BUZZER_PIN = D0;

LiquidCrystal_I2C lcd(0x27, 16, 2);

bool systemArmed = true;
bool alarmActive = false;

void setup() {

  Serial.begin(115200);

  pinMode(REED_PIN, INPUT_PULLUP);
  pinMode(PIR_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  digitalWrite(BUZZER_PIN, LOW);

  lcd.init();
  lcd.backlight();

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Security System");

  delay(1500);

  updateDisplay();
}

void loop() {

  if (!systemArmed) {

    digitalWrite(BUZZER_PIN, LOW);

    return;
  }

  bool doorOpen = digitalRead(REED_PIN) == HIGH;
  bool motionDetected = digitalRead(PIR_PIN) == HIGH;

  if (doorOpen) {

    activateAlarm("Door Open");
  }
  else if (motionDetected) {

    activateAlarm("Motion Det.");
  }
  else {

    if (!alarmActive) {

      digitalWrite(BUZZER_PIN, LOW);

      lcd.setCursor(0, 0);
      lcd.print("System: ARMED  ");

      lcd.setCursor(0, 1);
      lcd.print("Area Secure     ");
    }
  }

  delay(100);
}

void activateAlarm(const char* message) {

  alarmActive = true;

  digitalWrite(BUZZER_PIN, HIGH);

  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.print("ALARM!");

  lcd.setCursor(0, 1);
  lcd.print(message);

  Serial.print("ALARM: ");
  Serial.println(message);
}

void updateDisplay() {

  lcd.clear();

  if (systemArmed) {

    lcd.setCursor(0, 0);
    lcd.print("System: ARMED");

  } else {

    lcd.setCursor(0, 0);
    lcd.print("System: OFF");
  }
}

Recommended Improvement

For the actual Makers kit, add an Arm/Disarm push button or keypad command rather than hard-coding:

bool systemArmed = true;

That turns the project into a more realistic security system.

15. Project 10 — Complete Smart Home

The final project combines the concepts introduced throughout the previous nine projects.

Possible Components

• ESP8266 NodeMCU
• LDR
• PIR
• Reed switch
• DHT22
• Relay
• LED/light
• DC fan
• Servo
• Keypad
• Buzzer
• LCD/OLED
• Push buttons
• Wi-Fi network

System Architecture

                       SMART HOME
                           │
                           ▼
                    ESP8266 NodeMCU
                           │
       ┌───────────────────┼───────────────────┐
       │                   │                   │
       ▼                   ▼                   ▼
     Sensors            Actuators           Display
       │                   │                   │
 ┌─────┼─────┐       ┌─────┼─────┐       ┌────┴────┐
 │     │     │       │     │     │       │         │
LDR   PIR   Reed    Relay  LED  Servo   LCD       OLED
 │     │     │       │     │     │
 └─────┼─────┴───────┴─────┴─────┘
       │
      DHT22
       │
       ▼
    Temperature
       │
       ▼
   Fan Control

                           │
                           ▼
                         Wi-Fi
                           │
                           ▼
                  Phone / Web Interface

Example Automation Rules

The final system can implement rules such as:

Rule 1 — Lighting    Dark + motion → Light ON

Rule 2 — Fan     Temperature above threshold → Fan ON

Rule 3 — Door   Door opens while security is armed → Alarm ON

Rule 4 — Motion   Motion while security is armed → Alarm ON

Rule 5 — Access     Correct password → Unlock door

Rule 6 — Remote Control      Wi-Fi command → ESP8266 → Selected output

• This demonstrates how individual circuits can be combined into a complete automation system.
• The final project should not simply repeat the previous programs. It should combine them using a modular program structure.

The following is a foundation version that combines:

• LDR
• PIR
• Reed switch
• DHT22
• Relay/light
• Fan relay
• Buzzer
• Servo
• OLED/LCD-compatible status concept
• Wi-Fi

Because Project 10 has many peripherals, the final physical pin allocation should be finalized after selecting the exact keypad/display/relay modules.

Arduino IDE Code

#include <ESP8266WiFi.h>
#include <DHT.h>
#include <Servo.h>

#define DHT_PIN D5
#define DHT_TYPE DHT22

const int LDR_PIN = A0;
const int PIR_PIN = D6;
const int REED_PIN = D7;

const int LIGHT_RELAY_PIN = D1;
const int FAN_RELAY_PIN = D2;

const int BUZZER_PIN = D0;
const int SERVO_PIN = D4;

const int DARK_THRESHOLD = 500;

const float FAN_ON_TEMP = 30.0;
const float FAN_OFF_TEMP = 28.0;

const unsigned long LIGHT_TIMEOUT = 30000;

const int LOCK_POSITION = 0;
const int UNLOCK_POSITION = 90;

// Wi-Fi settings
const char* WIFI_SSID = "YOUR_WIFI_NAME";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

DHT dht(DHT_PIN, DHT_TYPE);

Servo doorServo;

bool lightState = false;
bool fanState = false;
bool alarmState = false;

unsigned long lastMotionTime = 0;

void setup() {

  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(REED_PIN, INPUT_PULLUP);

  pinMode(LIGHT_RELAY_PIN, OUTPUT);
  pinMode(FAN_RELAY_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  // Active-low relay modules
  digitalWrite(LIGHT_RELAY_PIN, HIGH);
  digitalWrite(FAN_RELAY_PIN, HIGH);

  digitalWrite(BUZZER_PIN, LOW);

  doorServo.attach(SERVO_PIN);
  doorServo.write(LOCK_POSITION);

  dht.begin();

  connectWiFi();

  Serial.println();
  Serial.println("Makers Smart Home");
  Serial.println("System Ready");
}

void loop() {

  readSensors();

  controlLighting();

  controlFan();

  checkSecurity();

  handleDoorLock();

  delay(100);
}

void readSensors() {

  int lightValue = analogRead(LDR_PIN);
  int motion = digitalRead(PIR_PIN);
  int door = digitalRead(REED_PIN);

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  Serial.println("----------------------");

  Serial.print("Light: ");
  Serial.println(lightValue);

  Serial.print("Motion: ");
  Serial.println(motion);

  Serial.print("Door: ");
  Serial.println(door);

  if (!isnan(temperature)) {

    Serial.print("Temperature: ");
    Serial.print(temperature);
    Serial.println(" C");
  }

  if (!isnan(humidity)) {

    Serial.print("Humidity: ");
    Serial.print(humidity);
    Serial.println(" %");
  }
}

void controlLighting() {

  int lightValue = analogRead(LDR_PIN);
  int motion = digitalRead(PIR_PIN);

  bool dark = lightValue < DARK_THRESHOLD;

  if (motion == HIGH) {

    lastMotionTime = millis();
  }

  bool recentMotion =
    millis() - lastMotionTime < LIGHT_TIMEOUT;

  if (dark && recentMotion) {

    if (!lightState) {

      digitalWrite(LIGHT_RELAY_PIN, LOW);

      lightState = true;

      Serial.println("Smart Light: ON");
    }

  } else {

    if (lightState) {

      digitalWrite(LIGHT_RELAY_PIN, HIGH);

      lightState = false;

      Serial.println("Smart Light: OFF");
    }
  }
}

void controlFan() {

  float temperature = dht.readTemperature();

  if (isnan(temperature)) {
    return;
  }

  if (!fanState && temperature >= FAN_ON_TEMP) {

    fanState = true;

    digitalWrite(FAN_RELAY_PIN, LOW);

    Serial.println("Fan: ON");
  }

  if (fanState && temperature <= FAN_OFF_TEMP) {

    fanState = false;

    digitalWrite(FAN_RELAY_PIN, HIGH);

    Serial.println("Fan: OFF");
  }
}

void checkSecurity() {

  bool doorOpen = digitalRead(REED_PIN) == HIGH;
  bool motionDetected = digitalRead(PIR_PIN) == HIGH;

  if (doorOpen || motionDetected) {

    alarmState = true;

    digitalWrite(BUZZER_PIN, HIGH);

    if (doorOpen) {

      Serial.println("SECURITY: Door Open");
    }

    if (motionDetected) {

      Serial.println("SECURITY: Motion Detected");
    }

  } else {

    alarmState = false;

    digitalWrite(BUZZER_PIN, LOW);
  }
}

void handleDoorLock() {

  // Placeholder for keypad/password logic.

  // In the complete version:
  //
  // Correct password
  //       ↓
  // Servo → UNLOCK_POSITION
  //
  // Timeout
  //       ↓
  // Servo → LOCK_POSITION
}

void connectWiFi() {

  Serial.print("Connecting to Wi-Fi");

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  unsigned long startAttempt = millis();

  while (WiFi.status() != WL_CONNECTED &&
         millis() - startAttempt < 15000) {

    delay(500);

    Serial.print(".");
  }

  Serial.println();

  if (WiFi.status() == WL_CONNECTED) {

    Serial.println("Wi-Fi Connected");

    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());

  } else {

    Serial.println("Wi-Fi Connection Failed");

    // The smart-home functions continue
    // to operate locally.
  }
}

Important improvement for Project 10

I would not publish this Project 10 code as the final production code yet because the complete system needs one final hardware decision: which display and keypad architecture will be included in the actual Makers Smart Home Kit.

The ESP8266 has limited GPIO compared with an ESP32, so trying to connect every peripheral directly can create pin conflicts. This is especially important when combining:

• 4×4 keypad
• LCD
• Servo
• multiple sensors
• two relays
• buzzer
• Wi-Fi

A cleaner professional design is to use I²C peripherals and/or an I/O expander for the final kit.

16. Programming and Wi-Fi Connectivity

The programming approach should also progress with the hardware.

Basic Programming

The first projects can use simple Arduino-style functions:

setup()
loop()
pinMode()
digitalRead()
digitalWrite()
analogRead()

This makes the first experiments easier for beginners.

Sensor Processing

As the projects become more advanced, the program can be organized into separate functions:

readLightSensor()
readMotionSensor()
readDoorSensor()
readTemperature()
controlLight()
controlFan()
controlAlarm()
controlDoorLock()
updateDisplay()

This approach makes the code easier to understand and maintain.

Automation Logic

Rather than placing all conditions into one large loop(), the program can be divided into logical tasks.

For example:

Read Sensors
      ↓
Update System State
      ↓
Apply Automation Rules
      ↓
Control Outputs
      ↓
Update Display
      ↓
Handle Wi-Fi
      ↓
Repeat

This architecture becomes particularly important in the Complete Smart Home project.

Wi-Fi Features

The ESP8266 can connect to a home Wi-Fi router and communicate using standard network protocols.

Possible educational features include:

• Displaying sensor readings on a web page
• Turning a light ON/OFF from a phone
• Monitoring room temperature remotely
• Checking door status
• Displaying security status
• Sending sensor data to an IoT platform

The ESP8266 supports TCP/IP networking and Wi-Fi station and SoftAP modes.

For an introductory Makers project, a simple local web dashboard is a good starting point because it demonstrates IoT functionality without requiring a separate mobile application.

17. Safety and Design Considerations

Use Low-Voltage Loads in the Learning Kit?

The safest approach for a beginner-oriented educational kit is to use:

• LEDs
• 5 V or 12 V lamps
• Low-voltage DC fans
• Servo motors
• Buzzer modules

For the relay experiments, the relay can demonstrate the principle of switching without requiring the learner to connect directly to household mains.

If mains-powered equipment is ever used, the installation should be performed using appropriate rated components, enclosure, insulation, fusing, and electrical protection by a suitably qualified person.

Do Not Power Loads Directly From GPIO

An ESP8266 GPIO is a control signal, not a general-purpose power supply.

For example:

• Incorrect:   ESP8266 GPIO → DC fan
• Correct:  ESP8266 GPIO → suitable driver/relay → DC fan

The same principle applies to other loads whose current requirements exceed the GPIO’s safe operating limits.

Pay Attention to ESP8266 Boot Pins

GPIO0, GPIO2, and GPIO15 participate in the ESP8266 boot-mode selection. External circuits connected to these pins must not force inappropriate levels during startup.

This is particularly important when designing a reusable kit where different modules may remain connected while the board is reset.

Power Supply

The ESP8266 requires a stable 3.3 V operating supply at the chip level, and Wi-Fi transmission can create significant instantaneous current demand. Espressif specifies a 2.5–3.6 V operating range for the ESP8266EX, while the Arduino ESP8266 documentation recommends adequate supply capability and filtering for stable operation.

The USB-powered NodeMCU board handles the conversion to the ESP8266’s operating voltage, but the power supply must still be adequate for the board and connected peripherals.

LDR and the ADC

The ESP8266 provides only one user ADC input, so the LDR project should use A0 and the rest of the kit should preferentially use digital or I²C devices.

Also, do not assume that every ESP8266 development board has the same A0 voltage range. The bare ESP8266 ADC input is specified for 0–1.0 V, while some development boards include an input divider. The exact NodeMCU board should therefore be checked before applying an external analog voltage.

18. Frequently Asked Questions

Can the ESP8266 run all ten Makers Smart Home projects?

Yes. The ESP8266 provides enough digital interfaces for the proposed projects, while the single ADC can be reserved for the LDR. The kit should be designed carefully around the available GPIO and boot-sensitive pins.

Why use ESP8266 instead of an Arduino Uno?

The major advantage for this particular kit is integrated Wi-Fi. An Arduino Uno can control sensors and actuators, but adding Wi-Fi normally requires an additional communication module. The ESP8266 combines the controller and Wi-Fi functionality in one platform.

Does the ESP8266 have Bluetooth?

No. The ESP8266 is a Wi-Fi platform; it should not be selected when Bluetooth is a required feature.

Can the LDR and DHT22 be used together?

Yes. The LDR uses the ESP8266’s analog input, while the DHT22 communicates through a digital GPIO. They therefore do not require the same type of interface.

Can I connect several analog sensors to the ESP8266?

Not directly to separate built-in ADC channels because the ESP8266 has one user-accessible ADC channel. An external ADC or suitable analog multiplexer can be added if a future version of the kit requires several analog measurements.

Can the relay control a household appliance?

A relay can electrically switch a suitable load, but for a beginner educational kit it is preferable to demonstrate the circuit using low-voltage DC loads. Mains-voltage wiring requires appropriate electrical safety measures and qualified installation.

Can the kit be controlled from a smartphone?

Yes. The ESP8266’s Wi-Fi capability makes local web control, IoT dashboards, and other network-based interfaces possible.

Is the Makers Smart Home Kit only for beginners?

No. The first projects are deliberately beginner-friendly, but the later projects introduce multi-sensor logic, access control, state management, networking, and IoT concepts that can also be useful to electronics students, hobbyists, and engineers.

Can the same components be reused for different projects?

Yes. Reusability is one of the main advantages of the kit. For example, the same PIR can be used for the Motion Activated Light, Security Motion Alarm, Smart Room Controller, Home Security System, and Complete Smart Home projects.

What is the main purpose of the ten-project structure?

The projects are arranged as a learning progression. The learner starts with a single sensor and output and gradually moves toward a multi-sensor Wi-Fi smart-home system.

19. Conclusion

The Makers Smart Home Kit: 10 Practical ESP8266 Projects for Smart Home Automation provides a structured way to learn how modern smart-home systems are built.

Instead of treating each component as an isolated experiment, the ten projects progressively introduce the complete automation chain:

Sensors → ESP8266 → Decision Logic → Actuators → Display → Wi-Fi

The first projects establish the fundamentals with automatic lighting, motion detection, and door alarms. The following projects introduce temperature control, relays, servo motors, keypads, and displays. The final projects combine these elements into multi-sensor security and smart-home systems.

The ESP8266 is particularly suitable for this educational approach because Wi-Fi and several common microcontroller interfaces are integrated into the platform.

For Makers Electronics, the key value of this kit is therefore not simply the number of components included. It is the progressive learning path that allows a beginner to start with a simple LED and eventually build a practical Wi-Fi-connected smart-home controller.

Recommended Sources and Reference Ranking

For this article, I would keep the source list intentionally small and prioritize primary technical documentation first, followed by well-established educational references:

1. Espressif Systems — ESP8266EX Datasheet
Best source for electrical specifications, GPIO, ADC, Wi-Fi capabilities, interfaces, power requirements, and official application information.

Espressif ESP8266EX Datasheet

2. ESP8266 Arduino Core Documentation
Best practical software reference for Arduino IDE programming, GPIO, analog input, Wi-Fi libraries, I²C, SPI, and development-board configuration.

ESP8266 Arduino Core Documentation

3. Adafruit Learning System — DHT Sensors / Display Guides
Useful for beginner-friendly explanations and practical interfacing examples for components such as DHT sensors and SSD1306 displays.

Adafruit DHT Sensor Guide

Important current note: Espressif’s November 2025 ESP8266EX datasheet now marks the ESP8266EX as “Not Recommended for New Designs (NRND)” and points to newer Espressif devices. For this article, that does not prevent using an existing ESP8266 NodeMCU board as the basis of an educational Makers kit, but it is worth keeping in mind if Makers later develops a new-generation version of the kit.

const int LDR_PIN = A0;
const int LED_PIN = D6;

// Adjust this value after testing your LDR circuit.
const int LIGHT_THRESHOLD = 500;

void setup() {
  Serial.begin(115200);

  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  Serial.println("Automatic Night Light");
}

void loop() {
  int lightValue = analogRead(LDR_PIN);

  Serial.print("LDR Value: ");
  Serial.println(lightValue);

  // Adjust this comparison according to your voltage-divider orientation.
  if (lightValue < LIGHT_THRESHOLD) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }

  delay(200);
}

Start
  ↓
Read PIR
  ↓
Motion detected?
  ├── No → Keep LED OFF
  └── Yes
       ↓
     LED ON
       ↓
    Wait period
       ↓
     LED OFF

const int PIR_PIN = D5;
const int LED_PIN = D6;

const unsigned long LIGHT_ON_TIME = 10000; // 10 seconds

unsigned long motionTime = 0;
bool lightOn = false;

void setup() {
  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);

  digitalWrite(LED_PIN, LOW);

  Serial.println("Motion Activated Light");
}

void loop() {
  int motionState = digitalRead(PIR_PIN);

  if (motionState == HIGH) {
    digitalWrite(LED_PIN, HIGH);

    lightOn = true;
    motionTime = millis();

    Serial.println("Motion detected");
  }

  if (lightOn && (millis() - motionTime >= LIGHT_ON_TIME)) {
    digitalWrite(LED_PIN, LOW);
    lightOn = false;

    Serial.println("Light OFF");
  }
}

const int REED_PIN = D7;
const int BUZZER_PIN = D0;

void setup() {
  Serial.begin(115200);

  pinMode(REED_PIN, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);

  digitalWrite(BUZZER_PIN, LOW);

  Serial.println("Door Open Alarm");
}

void loop() {

  int doorState = digitalRead(REED_PIN);

  // LOW = door closed
  // HIGH = door open
  if (doorState == HIGH) {

    digitalWrite(BUZZER_PIN, HIGH);

    Serial.println("WARNING: Door Open");
  }
  else {

    digitalWrite(BUZZER_PIN, LOW);

    Serial.println("Door Closed");
  }

  delay(100);
}

const int PIR_PIN = D5;
const int BUZZER_PIN = D0;
const int LED_PIN = D6;

const unsigned long ALARM_TIME = 10000; // 10 seconds

bool alarmActive = false;
unsigned long alarmStartTime = 0;

void setup() {
  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);

  digitalWrite(BUZZER_PIN, LOW);
  digitalWrite(LED_PIN, LOW);

  Serial.println("Security Motion Alarm");
}

void loop() {

  int motion = digitalRead(PIR_PIN);

  if (motion == HIGH && !alarmActive) {

    alarmActive = true;
    alarmStartTime = millis();

    Serial.println("MOTION DETECTED!");
  }

  if (alarmActive) {

    digitalWrite(BUZZER_PIN, HIGH);
    digitalWrite(LED_PIN, HIGH);

    if (millis() - alarmStartTime >= ALARM_TIME) {

      digitalWrite(BUZZER_PIN, LOW);
      digitalWrite(LED_PIN, LOW);

      alarmActive = false;

      Serial.println("Alarm Reset");
    }
  }
}

NORMAL
   ↓
Motion detected
   ↓
ALARM ACTIVE
   ↓
Timeout
   ↓
NORMAL

#include <DHT.h>

#define DHT_PIN D5
#define DHT_TYPE DHT22

const int RELAY_PIN = D6;

const float FAN_ON_TEMP = 30.0;
const float FAN_OFF_TEMP = 28.0;

DHT dht(DHT_PIN, DHT_TYPE);

bool fanState = false;

void setup() {
  Serial.begin(115200);

  dht.begin();

  pinMode(RELAY_PIN, OUTPUT);

  // Change these if your relay is active HIGH.
  digitalWrite(RELAY_PIN, HIGH);

  Serial.println("Automatic Fan Controller");
}

void loop() {

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  if (isnan(temperature) || isnan(humidity)) {

    Serial.println("DHT22 reading failed");
    delay(2000);

    return;
  }

  Serial.print("Temperature: ");
  Serial.print(temperature);
  Serial.println(" C");

  Serial.print("Humidity: ");
  Serial.print(humidity);
  Serial.println(" %");

  // Hysteresis control
  if (!fanState && temperature >= FAN_ON_TEMP) {

    fanState = true;

    digitalWrite(RELAY_PIN, LOW);

    Serial.println("Fan ON");
  }

  if (fanState && temperature <= FAN_OFF_TEMP) {

    fanState = false;

    digitalWrite(RELAY_PIN, HIGH);

    Serial.println("Fan OFF");
  }

  delay(2000);
}

#include <Servo.h>

const int BUTTON_PIN = D7;
const int SERVO_PIN = D4;

const int LOCK_POSITION = 0;
const int UNLOCK_POSITION = 90;

Servo doorServo;

void setup() {
  Serial.begin(115200);

  pinMode(BUTTON_PIN, INPUT_PULLUP);

  doorServo.attach(SERVO_PIN);

  doorServo.write(LOCK_POSITION);

  Serial.println("Electronic Door Lock");
}

void loop() {

  int buttonState = digitalRead(BUTTON_PIN);

  if (buttonState == LOW) {

    Serial.println("Unlocking...");

    doorServo.write(UNLOCK_POSITION);

    delay(3000);

    Serial.println("Locking...");

    doorServo.write(LOCK_POSITION);

    // Prevent repeated triggering
    delay(500);
  }
}

Enter password
      ↓
Compare
      ↓
Correct
      ↓
Servo UNLOCK
      ↓
Delay
      ↓
Servo LOCK

Enter password
      ↓
Compare
      ↓
Incorrect
      ↓
Buzzer
      ↓
Access Denied

#include <Keypad.h>
#include <Servo.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

const byte ROWS = 4;
const byte COLS = 3;

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

byte rowPins[ROWS] = {D1, D2, D5, D6};
byte colPins[COLS] = {D7, D8, D0};

Keypad keypad = Keypad(
  makeKeymap(keys),
  rowPins,
  colPins,
  ROWS,
  COLS
);

LiquidCrystal_I2C lcd(0x27, 16, 2);

Servo doorServo;

const int SERVO_PIN = D4;
const int BUZZER_PIN = D3;

const int LOCK_POSITION = 0;
const int UNLOCK_POSITION = 90;

const char PASSWORD[] = "1234";

String enteredPassword = "";

void setup() {

  Serial.begin(115200);

  pinMode(BUZZER_PIN, OUTPUT);

  doorServo.attach(SERVO_PIN);
  doorServo.write(LOCK_POSITION);

  lcd.init();
  lcd.backlight();

  lcd.setCursor(0, 0);
  lcd.print("Enter Password");

  lcd.setCursor(0, 1);
}

void loop() {

  char key = keypad.getKey();

  if (key == NO_KEY) {
    return;
  }

  if (key == '#') {

    checkPassword();

    return;
  }

  if (key == '*') {

    enteredPassword = "";

    lcd.clear();
    lcd.print("Password Clear");

    delay(1000);

    showPasswordPrompt();

    return;
  }

  if (enteredPassword.length() < 8) {

    enteredPassword += key;

    lcd.setCursor(enteredPassword.length() - 1, 1);
    lcd.print('*');
  }
}

void checkPassword() {

  if (enteredPassword == PASSWORD) {

    lcd.clear();
    lcd.print("Access Granted");

    Serial.println("Correct Password");

    doorServo.write(UNLOCK_POSITION);

    delay(3000);

    doorServo.write(LOCK_POSITION);

  } else {

    lcd.clear();
    lcd.print("Access Denied");

    Serial.println("Incorrect Password");

    digitalWrite(BUZZER_PIN, HIGH);
    delay(1000);
    digitalWrite(BUZZER_PIN, LOW);
  }

  enteredPassword = "";

  delay(1000);

  showPasswordPrompt();
}

void showPasswordPrompt() {

  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.print("Enter Password");

  lcd.setCursor(0, 1);
}

              ┌── Room bright ──→ Light OFF
              │
LDR ──────────┤
              │
              └── Room dark
                       │
                       ▼
                     Check PIR
                       │
             ┌─────────┴─────────┐
             │                   │
       Motion detected      No motion
             │                   │
             ▼                   ▼
         Light ON          Light OFF

const int LDR_PIN = A0;
const int PIR_PIN = D5;
const int RELAY_PIN = D6;

const int DARK_THRESHOLD = 500;

const unsigned long LIGHT_TIMEOUT = 30000;

unsigned long lastMotionTime = 0;

bool lightState = false;

void setup() {

  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);

  // Relay OFF for an active-low module
  digitalWrite(RELAY_PIN, HIGH);

  Serial.println("Smart Room Controller");
}

void loop() {

  int lightValue = analogRead(LDR_PIN);
  int motion = digitalRead(PIR_PIN);

  bool dark = lightValue < DARK_THRESHOLD;

  if (motion == HIGH) {

    lastMotionTime = millis();

    Serial.println("Motion detected");
  }

  if (dark && (millis() - lastMotionTime < LIGHT_TIMEOUT)) {

    if (!lightState) {

      digitalWrite(RELAY_PIN, LOW);
      lightState = true;

      Serial.println("Room Light ON");
    }

  } else {

    if (lightState) {

      digitalWrite(RELAY_PIN, HIGH);
      lightState = false;

      Serial.println("Room Light OFF");
    }
  }

  delay(100);
}

Dark?
  +
Motion recently detected?
  ↓
Light ON

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

const int REED_PIN = D7;
const int PIR_PIN = D5;
const int BUZZER_PIN = D0;

LiquidCrystal_I2C lcd(0x27, 16, 2);

bool systemArmed = true;
bool alarmActive = false;

void setup() {

  Serial.begin(115200);

  pinMode(REED_PIN, INPUT_PULLUP);
  pinMode(PIR_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  digitalWrite(BUZZER_PIN, LOW);

  lcd.init();
  lcd.backlight();

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Security System");

  delay(1500);

  updateDisplay();
}

void loop() {

  if (!systemArmed) {

    digitalWrite(BUZZER_PIN, LOW);

    return;
  }

  bool doorOpen = digitalRead(REED_PIN) == HIGH;
  bool motionDetected = digitalRead(PIR_PIN) == HIGH;

  if (doorOpen) {

    activateAlarm("Door Open");
  }
  else if (motionDetected) {

    activateAlarm("Motion Det.");
  }
  else {

    if (!alarmActive) {

      digitalWrite(BUZZER_PIN, LOW);

      lcd.setCursor(0, 0);
      lcd.print("System: ARMED  ");

      lcd.setCursor(0, 1);
      lcd.print("Area Secure     ");
    }
  }

  delay(100);
}

void activateAlarm(const char* message) {

  alarmActive = true;

  digitalWrite(BUZZER_PIN, HIGH);

  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.print("ALARM!");

  lcd.setCursor(0, 1);
  lcd.print(message);

  Serial.print("ALARM: ");
  Serial.println(message);
}

void updateDisplay() {

  lcd.clear();

  if (systemArmed) {

    lcd.setCursor(0, 0);
    lcd.print("System: ARMED");

  } else {

    lcd.setCursor(0, 0);
    lcd.print("System: OFF");
  }
}

bool systemArmed = true;

                       SMART HOME
                           │
                           ▼
                    ESP8266 NodeMCU
                           │
       ┌───────────────────┼───────────────────┐
       │                   │                   │
       ▼                   ▼                   ▼
     Sensors            Actuators           Display
       │                   │                   │
 ┌─────┼─────┐       ┌─────┼─────┐       ┌────┴────┐
 │     │     │       │     │     │       │         │
LDR   PIR   Reed    Relay  LED  Servo   LCD       OLED
 │     │     │       │     │     │
 └─────┼─────┴───────┴─────┴─────┘
       │
      DHT22
       │
       ▼
    Temperature
       │
       ▼
   Fan Control

                           │
                           ▼
                         Wi-Fi
                           │
                           ▼
                  Phone / Web Interface

#include <ESP8266WiFi.h>
#include <DHT.h>
#include <Servo.h>

#define DHT_PIN D5
#define DHT_TYPE DHT22

const int LDR_PIN = A0;
const int PIR_PIN = D6;
const int REED_PIN = D7;

const int LIGHT_RELAY_PIN = D1;
const int FAN_RELAY_PIN = D2;

const int BUZZER_PIN = D0;
const int SERVO_PIN = D4;

const int DARK_THRESHOLD = 500;

const float FAN_ON_TEMP = 30.0;
const float FAN_OFF_TEMP = 28.0;

const unsigned long LIGHT_TIMEOUT = 30000;

const int LOCK_POSITION = 0;
const int UNLOCK_POSITION = 90;

// Wi-Fi settings
const char* WIFI_SSID = "YOUR_WIFI_NAME";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

DHT dht(DHT_PIN, DHT_TYPE);

Servo doorServo;

bool lightState = false;
bool fanState = false;
bool alarmState = false;

unsigned long lastMotionTime = 0;

void setup() {

  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(REED_PIN, INPUT_PULLUP);

  pinMode(LIGHT_RELAY_PIN, OUTPUT);
  pinMode(FAN_RELAY_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  // Active-low relay modules
  digitalWrite(LIGHT_RELAY_PIN, HIGH);
  digitalWrite(FAN_RELAY_PIN, HIGH);

  digitalWrite(BUZZER_PIN, LOW);

  doorServo.attach(SERVO_PIN);
  doorServo.write(LOCK_POSITION);

  dht.begin();

  connectWiFi();

  Serial.println();
  Serial.println("Makers Smart Home");
  Serial.println("System Ready");
}

void loop() {

  readSensors();

  controlLighting();

  controlFan();

  checkSecurity();

  handleDoorLock();

  delay(100);
}

void readSensors() {

  int lightValue = analogRead(LDR_PIN);
  int motion = digitalRead(PIR_PIN);
  int door = digitalRead(REED_PIN);

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  Serial.println("----------------------");

  Serial.print("Light: ");
  Serial.println(lightValue);

  Serial.print("Motion: ");
  Serial.println(motion);

  Serial.print("Door: ");
  Serial.println(door);

  if (!isnan(temperature)) {

    Serial.print("Temperature: ");
    Serial.print(temperature);
    Serial.println(" C");
  }

  if (!isnan(humidity)) {

    Serial.print("Humidity: ");
    Serial.print(humidity);
    Serial.println(" %");
  }
}

void controlLighting() {

  int lightValue = analogRead(LDR_PIN);
  int motion = digitalRead(PIR_PIN);

  bool dark = lightValue < DARK_THRESHOLD;

  if (motion == HIGH) {

    lastMotionTime = millis();
  }

  bool recentMotion =
    millis() - lastMotionTime < LIGHT_TIMEOUT;

  if (dark && recentMotion) {

    if (!lightState) {

      digitalWrite(LIGHT_RELAY_PIN, LOW);

      lightState = true;

      Serial.println("Smart Light: ON");
    }

  } else {

    if (lightState) {

      digitalWrite(LIGHT_RELAY_PIN, HIGH);

      lightState = false;

      Serial.println("Smart Light: OFF");
    }
  }
}

void controlFan() {

  float temperature = dht.readTemperature();

  if (isnan(temperature)) {
    return;
  }

  if (!fanState && temperature >= FAN_ON_TEMP) {

    fanState = true;

    digitalWrite(FAN_RELAY_PIN, LOW);

    Serial.println("Fan: ON");
  }

  if (fanState && temperature <= FAN_OFF_TEMP) {

    fanState = false;

    digitalWrite(FAN_RELAY_PIN, HIGH);

    Serial.println("Fan: OFF");
  }
}

void checkSecurity() {

  bool doorOpen = digitalRead(REED_PIN) == HIGH;
  bool motionDetected = digitalRead(PIR_PIN) == HIGH;

  if (doorOpen || motionDetected) {

    alarmState = true;

    digitalWrite(BUZZER_PIN, HIGH);

    if (doorOpen) {

      Serial.println("SECURITY: Door Open");
    }

    if (motionDetected) {

      Serial.println("SECURITY: Motion Detected");
    }

  } else {

    alarmState = false;

    digitalWrite(BUZZER_PIN, LOW);
  }
}

void handleDoorLock() {

  // Placeholder for keypad/password logic.

  // In the complete version:
  //
  // Correct password
  //       ↓
  // Servo → UNLOCK_POSITION
  //
  // Timeout
  //       ↓
  // Servo → LOCK_POSITION
}

void connectWiFi() {

  Serial.print("Connecting to Wi-Fi");

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  unsigned long startAttempt = millis();

  while (WiFi.status() != WL_CONNECTED &&
         millis() - startAttempt < 15000) {

    delay(500);

    Serial.print(".");
  }

  Serial.println();

  if (WiFi.status() == WL_CONNECTED) {

    Serial.println("Wi-Fi Connected");

    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());

  } else {

    Serial.println("Wi-Fi Connection Failed");

    // The smart-home functions continue
    // to operate locally.
  }
}

setup()
loop()
pinMode()
digitalRead()
digitalWrite()
analogRead()

readLightSensor()
readMotionSensor()
readDoorSensor()
readTemperature()
controlLight()
controlFan()
controlAlarm()
controlDoorLock()
updateDisplay()

Read Sensors
      ↓
Update System State
      ↓
Apply Automation Rules
      ↓
Control Outputs
      ↓
Update Display
      ↓
Handle Wi-Fi
      ↓
Repeat