Building a Smart Home System with Raspberry Pi and IoT Sensors

Introduction to Smart Home Automation

Smart home automation has become increasingly accessible thanks to affordable single-board computers like the Raspberry Pi. In this comprehensive guide, we'll build a complete home automation system that can monitor environmental conditions, control lighting, manage security, and provide remote access through a web interface.

Our system will include temperature and humidity monitoring, motion detection, automated lighting control, and a web dashboard for remote management. By the end of this tutorial, you'll have a fully functional smart home hub that you can expand and customise to meet your specific needs.

Components and Hardware Requirements

For this project, you'll need the following components. All items are available from EnergySmart EnerGlow with competitive pricing and fast UK delivery:

Core Components

• Raspberry Pi 4 Model B (4GB RAM): The main controller for our smart home system
• MicroSD Card (32GB Class 10): For the operating system and data storage
• Official Raspberry Pi Power Supply: Reliable 5V 3A USB-C power adapter
• Raspberry Pi Case: For protection and heat dissipation

Sensors and Modules

• DHT22 Temperature/Humidity Sensor: For environmental monitoring
• PIR Motion Sensor (HC-SR501): For motion detection and security
• Light Dependent Resistor (LDR): For ambient light sensing
• MCP3008 ADC: For reading analogue sensors
• 5V Relay Module: For controlling high-voltage devices
• RGB LED Strip (5V): For smart lighting demonstration

Additional Components

• Breadboard and Jumper Wires: For prototyping connections
• Resistors: 10kΩ for pull-up/pull-down configurations
• Capacitors: 0.1µF ceramic capacitors for noise filtering

Setting Up the Raspberry Pi

Before we start connecting sensors, we need to prepare our Raspberry Pi with the necessary software and configurations.

Installing Raspberry Pi OS

1. Download the Raspberry Pi Imager from the official website
2. Flash Raspberry Pi OS Lite to your microSD card
3. Enable SSH by creating an empty file named 'ssh' in the boot partition
4. Configure Wi-Fi by creating a 'wpa_supplicant.conf' file with your network credentials
5. Insert the SD card into your Pi and power it on

Initial Configuration

Once your Pi is running, connect via SSH and perform these initial setup steps:

# Update the system
sudo apt update && sudo apt upgrade -y

# Install required packages
sudo apt install python3-pip python3-venv git -y

# Enable GPIO and SPI interfaces
sudo raspi-config
# Navigate to Interface Options and enable SPI, I2C, and GPIO

Building the Temperature Monitoring System

Let's start by implementing a temperature and humidity monitoring system using the DHT22 sensor.

Hardware Connections

Connect the DHT22 sensor to your Raspberry Pi as follows:

• VCC (Pin 1) → 3.3V (Pin 1 on Pi)
• Data (Pin 2) → GPIO 4 (Pin 7 on Pi)
• GND (Pin 4) → Ground (Pin 6 on Pi)
• Add a 10kΩ pull-up resistor between VCC and Data pins

Python Code for Temperature Monitoring

Create a Python script to read temperature and humidity data:

#!/usr/bin/env python3
import time
import board
import adafruit_dht
import sqlite3
from datetime import datetime

# Initialize DHT22 sensor
dht = adafruit_dht.DHT22(board.D4)

# Database setup
def init_database():
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS temperature_data (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
            temperature REAL,
            humidity REAL
        )
    ''')
    conn.commit()
    conn.close()

def log_temperature():
    try:
        temperature = dht.temperature
        humidity = dht.humidity
        
        if temperature is not None and humidity is not None:
            conn = sqlite3.connect('smart_home.db')
            cursor = conn.cursor()
            cursor.execute(
                'INSERT INTO temperature_data (temperature, humidity) VALUES (?, ?)',
                (temperature, humidity)
            )
            conn.commit()
            conn.close()
            
            print(f"Temperature: {temperature:.1f}°C, Humidity: {humidity:.1f}%")
            return temperature, humidity
        else:
            print("Sensor reading error")
            return None, None
            
    except Exception as e:
        print(f"Error reading sensor: {e}")
        return None, None

if __name__ == "__main__":
    init_database()
    
    while True:
        log_temperature()
        time.sleep(60)  # Read every minute

Implementing Motion Detection and Security

Next, we'll add motion detection capabilities using a PIR sensor for basic security monitoring.

PIR Sensor Connection

• VCC → 5V (Pin 2 on Pi)
• OUT → GPIO 18 (Pin 12 on Pi)
• GND → Ground (Pin 14 on Pi)

Motion Detection Code

#!/usr/bin/env python3
import RPi.GPIO as GPIO
import time
import sqlite3
from datetime import datetime
import smtplib
from email.mime.text import MimeText

# GPIO setup
PIR_PIN = 18
GPIO.setmode(GPIO.BCM)
GPIO.setup(PIR_PIN, GPIO.IN)

def init_security_database():
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS motion_events (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
            location TEXT DEFAULT 'Living Room'
        )
    ''')
    conn.commit()
    conn.close()

def send_alert_email(message):
    """Send email alert when motion is detected"""
    try:
        smtp_server = "smtp.gmail.com"
        smtp_port = 587
        sender_email = "[email protected]"
        sender_password = "your-app-password"
        recipient_email = "[email protected]"
        
        msg = MimeText(message)
        msg['Subject'] = "Smart Home Security Alert"
        msg['From'] = sender_email
        msg['To'] = recipient_email
        
        with smtplib.SMTP(smtp_server, smtp_port) as server:
            server.starttls()
            server.login(sender_email, sender_password)
            server.send_message(msg)
            
        print("Alert email sent successfully")
    except Exception as e:
        print(f"Failed to send email: {e}")

def log_motion_event():
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute('INSERT INTO motion_events DEFAULT VALUES')
    conn.commit()
    conn.close()
    
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    message = f"Motion detected at {timestamp}"
    print(message)
    
    # Send email alert (optional)
    # send_alert_email(message)

def motion_callback(channel):
    if GPIO.input(PIR_PIN):
        log_motion_event()

if __name__ == "__main__":
    init_security_database()
    
    # Set up interrupt for motion detection
    GPIO.add_event_detect(PIR_PIN, GPIO.RISING, callback=motion_callback)
    
    print("Motion detection system active...")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("Shutting down motion detection...")
        GPIO.cleanup()

Smart Lighting Control System

Now let's implement an intelligent lighting system that responds to ambient light levels and can be controlled remotely.

Hardware Setup for Lighting

Connect the components for the lighting system:

• LDR and MCP3008 ADC: For reading ambient light levels
• Relay Module: For controlling mains-powered lights
• RGB LED Strip: For demonstration purposes

Lighting Control Code

#!/usr/bin/env python3
import time
import board
import busio
import digitalio
import adafruit_mcp3xxx.mcp3008 as MCP
from adafruit_mcp3xxx.analog_in import AnalogIn
import RPi.GPIO as GPIO

# SPI setup for MCP3008
spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
cs = digitalio.DigitalInOut(board.D8)
mcp = MCP.MCP3008(spi, cs)

# LDR connected to channel 0 of MCP3008
ldr = AnalogIn(mcp, MCP.P0)

# Relay control pin
RELAY_PIN = 21
GPIO.setmode(GPIO.BCM)
GPIO.setup(RELAY_PIN, GPIO.OUT)

class SmartLighting:
    def __init__(self):
        self.auto_mode = True
        self.light_threshold = 30000  # Adjust based on your LDR
        self.lights_on = False
        
    def read_light_level(self):
        """Read ambient light level from LDR"""
        return ldr.value
    
    def control_lights(self, state):
        """Control the lights (True = On, False = Off)"""
        GPIO.output(RELAY_PIN, state)
        self.lights_on = state
        status = "ON" if state else "OFF"
        print(f"Lights turned {status}")
    
    def auto_lighting_control(self):
        """Automatically control lights based on ambient light"""
        if not self.auto_mode:
            return
            
        light_level = self.read_light_level()
        print(f"Light level: {light_level}")
        
        # Turn on lights if it's dark and lights are off
        if light_level < self.light_threshold and not self.lights_on:
            self.control_lights(True)
            self.log_lighting_event("Auto ON - Low light detected")
            
        # Turn off lights if it's bright and lights are on
        elif light_level > self.light_threshold * 1.2 and self.lights_on:
            self.control_lights(False)
            self.log_lighting_event("Auto OFF - Sufficient light detected")
    
    def log_lighting_event(self, event):
        """Log lighting events to database"""
        import sqlite3
        conn = sqlite3.connect('smart_home.db')
        cursor = conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS lighting_events (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                event TEXT,
                light_level INTEGER
            )
        ''')
        cursor.execute(
            'INSERT INTO lighting_events (event, light_level) VALUES (?, ?)',
            (event, self.read_light_level())
        )
        conn.commit()
        conn.close()
        print(f"Logged: {event}")

if __name__ == "__main__":
    lighting = SmartLighting()
    
    try:
        while True:
            lighting.auto_lighting_control()
            time.sleep(10)  # Check every 10 seconds
            
    except KeyboardInterrupt:
        print("Shutting down lighting system...")
        GPIO.cleanup()

Creating a Web Dashboard

To make our smart home system user-friendly, let's create a web interface for monitoring and control.

Flask Web Application

Install Flask and create a web dashboard:

#!/usr/bin/env python3
from flask import Flask, render_template, jsonify, request
import sqlite3
import json
from datetime import datetime, timedelta

app = Flask(__name__)

def get_db_connection():
    conn = sqlite3.connect('smart_home.db')
    conn.row_factory = sqlite3.Row
    return conn

@app.route('/')
def dashboard():
    return render_template('dashboard.html')

@app.route('/api/temperature')
def get_temperature_data():
    conn = get_db_connection()
    cursor = conn.cursor()
    
    # Get last 24 hours of data
    cursor.execute('''
        SELECT temperature, humidity, timestamp 
        FROM temperature_data 
        WHERE timestamp > datetime('now', '-24 hours')
        ORDER BY timestamp DESC
        LIMIT 288
    ''')
    
    data = cursor.fetchall()
    conn.close()
    
    return jsonify([dict(row) for row in data])

@app.route('/api/motion')
def get_motion_events():
    conn = get_db_connection()
    cursor = conn.cursor()
    
    cursor.execute('''
        SELECT COUNT(*) as count, timestamp
        FROM motion_events 
        WHERE timestamp > datetime('now', '-24 hours')
    ''')
    
    data = cursor.fetchall()
    conn.close()
    
    return jsonify([dict(row) for row in data])

@app.route('/api/lights', methods=['GET', 'POST'])
def control_lights():
    if request.method == 'POST':
        # Control lights via web interface
        data = request.get_json()
        action = data.get('action')
        
        # Here you would interface with your lighting control system
        # For now, just return success
        return jsonify({'status': 'success', 'action': action})
    
    else:
        # Return current light status
        return jsonify({
            'status': 'on',  # This would come from your lighting system
            'auto_mode': True,
            'light_level': 25000
        })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

System Integration and Automation Rules

The final step is creating automation rules that make your smart home truly intelligent.

Creating Smart Automation Rules

#!/usr/bin/env python3
import time
import sqlite3
from datetime import datetime, time as dt_time
import threading

class HomeAutomation:
    def __init__(self):
        self.rules = [
            {
                'name': 'Evening Lights',
                'conditions': self.is_evening_and_dark,
                'actions': [self.turn_on_lights]
            },
            {
                'name': 'Night Security',
                'conditions': self.is_night_time,
                'actions': [self.activate_security_mode]
            },
            {
                'name': 'Morning Routine',
                'conditions': self.is_morning_with_motion,
                'actions': [self.morning_wake_up]
            }
        ]
    
    def is_evening_and_dark(self):
        """Check if it's evening and dark outside"""
        current_time = datetime.now().time()
        evening_start = dt_time(18, 0)  # 6 PM
        
        # Check if it's after 6 PM and light level is low
        light_level = self.get_current_light_level()
        return current_time >= evening_start and light_level < 30000
    
    def is_night_time(self):
        """Check if it's night time"""
        current_time = datetime.now().time()
        night_start = dt_time(22, 0)  # 10 PM
        night_end = dt_time(6, 0)     # 6 AM
        
        return current_time >= night_start or current_time <= night_end
    
    def is_morning_with_motion(self):
        """Check if it's morning and there's recent motion"""
        current_time = datetime.now().time()
        morning_start = dt_time(6, 0)   # 6 AM
        morning_end = dt_time(9, 0)     # 9 AM
        
        if not (morning_start <= current_time <= morning_end):
            return False
            
        # Check for motion in the last 5 minutes
        conn = sqlite3.connect('smart_home.db')
        cursor = conn.cursor()
        cursor.execute('''
            SELECT COUNT(*) FROM motion_events 
            WHERE timestamp > datetime('now', '-5 minutes')
        ''')
        motion_count = cursor.fetchone()[0]
        conn.close()
        
        return motion_count > 0
    
    def get_current_light_level(self):
        """Get current ambient light level"""
        # This would interface with your light sensor
        return 25000  # Placeholder
    
    def turn_on_lights(self):
        """Turn on the lights"""
        print("Automation: Turning on evening lights")
        # Interface with lighting system
    
    def activate_security_mode(self):
        """Activate enhanced security monitoring"""
        print("Automation: Activating night security mode")
        # Increase motion detection sensitivity
        # Enable additional sensors
    
    def morning_wake_up(self):
        """Execute morning wake-up routine"""
        print("Automation: Starting morning routine")
        # Gradually increase lighting
        # Start playing music
        # Display weather information
    
    def evaluate_rules(self):
        """Evaluate all automation rules"""
        for rule in self.rules:
            if rule['conditions']():
                print(f"Executing rule: {rule['name']}")
                for action in rule['actions']:
                    action()
    
    def run(self):
        """Main automation loop"""
        while True:
            try:
                self.evaluate_rules()
                time.sleep(30)  # Check rules every 30 seconds
            except KeyboardInterrupt:
                print("Stopping home automation...")
                break
            except Exception as e:
                print(f"Automation error: {e}")
                time.sleep(60)

if __name__ == "__main__":
    automation = HomeAutomation()
    automation.run()

Advanced Features and Expansions

Once you have the basic system running, consider these advanced features:

Voice Control Integration

Integrate with voice assistants like Google Assistant or Amazon Alexa using IFTTT (If This Then That) webhooks. This allows voice commands like "Turn off the living room lights" or "What's the temperature in the house?"

Mobile App Integration

Create a mobile app using frameworks like React Native or Flutter, or use existing home automation apps that support custom APIs.

Energy Monitoring

Add current sensors to monitor power consumption of various devices and create energy usage reports.

Weather Integration

Connect to weather APIs to make automation decisions based on weather conditions and forecasts.

Troubleshooting Common Issues

• Sensor Reading Errors: Check wiring connections and ensure proper power supply
• GPIO Conflicts: Make sure no two services are trying to use the same GPIO pins
• Database Locks: Implement proper database connection handling to avoid SQLite locks
• Network Connectivity: Ensure stable Wi-Fi connection for remote access features
• Power Issues: Use a quality power supply to avoid random reboots and sensor failures

Security Considerations

When building a connected smart home system, security should be a top priority:

• Change default passwords on all devices and services
• Use HTTPS for all web interfaces
• Implement proper authentication and authorization
• Keep your Raspberry Pi OS and software updated
• Use a VPN for remote access instead of exposing services directly to the internet
• Regularly backup your configuration and data

Conclusion

Building a smart home system with Raspberry Pi is an excellent way to learn about IoT, automation, and system integration. The modular approach we've taken allows you to start with basic functionality and gradually add more sophisticated features as your skills and needs evolve.

The combination of environmental monitoring, security features, intelligent lighting, and a web-based control interface provides a solid foundation for a comprehensive home automation system. With the addition of automation rules, your system becomes truly intelligent, responding to conditions and patterns without manual intervention.

Remember that home automation is an ongoing project. Start with the basics, ensure they work reliably, and then expand gradually. The key to a successful smart home system is reliability and user-friendliness rather than complexity.