Building a Smart Mirror with Raspberry Pi: S&S Creation Journey

Two-way mirror principle:
- Front: reflective (80%)
- Back: transparent (20%)
- Monitor behind mirror shines through dark areas
- Bright display + dark background = visible content

# Raspberry Pi script to control backlight
import os

def set_brightness(level: int):
    """Set display brightness (0-255)"""
    os.system(f'echo {level} > /sys/class/backlight/rpi_backlight/brightness')

# Set to maximum on startup
set_brightness(255)

┌─────────────────────────────────────┐
│         Smart Mirror UI             │
│         (React Frontend)            │
└─────────────────────────────────────┘
                 ↕ HTTP/WebSocket
┌─────────────────────────────────────┐
│      API Server (Node.js)           │
│   - Weather, calendar, news         │
│   - Smart home integration          │
└─────────────────────────────────────┘
                 ↕
┌─────────────────────────────────────┐
│   Hardware Controller (Python)      │
│   - Display control                 │
│   - Sensor reading                  │
│   - Camera interface                │
└─────────────────────────────────────┘
                 ↕
┌─────────────────────────────────────┐
│     Raspberry Pi GPIO               │
│   - PIR sensor, Camera, etc.        │
└─────────────────────────────────────┘

import RPi.GPIO as GPIO
import time
from typing import Callable

class SmartMirror:
    def __init__(self):
        self.pir_pin = 17
        self.is_active = False

        GPIO.setmode(GPIO.BCM)
        GPIO.setup(self.pir_pin, GPIO.IN)

    def on_motion_detected(self, callback: Callable):
        """Trigger callback when motion is detected"""
        def motion_callback(channel):
            if not self.is_active:
                self.is_active = True
                callback()

        GPIO.add_event_detect(
            self.pir_pin,
            GPIO.RISING,
            callback=motion_callback,
            bouncetime=2000
        )

    def wake_display(self):
        """Turn on display and load UI"""
        os.system('xset dpms force on')
        self.is_active = True

    def sleep_display(self):
        """Turn off display after inactivity"""
        os.system('xset dpms force off')
        self.is_active = False

    def start(self):
        """Main loop"""
        print("Smart Mirror started")
        self.on_motion_detected(self.wake_display)

        # Inactivity timer
        last_activity = time.time()
        timeout = 300  # 5 minutes

        while True:
            if self.is_active:
                if time.time() - last_activity > timeout:
                    self.sleep_display()
            time.sleep(1)

if __name__ == '__main__':
    mirror = SmartMirror()
    mirror.start()

// React component for mirror interface
import React, { useState, useEffect } from 'react';
import './MirrorUI.css';

const MirrorUI = () => {
  const [time, setTime] = useState(new Date());
  const [weather, setWeather] = useState(null);
  const [calendar, setCalendar] = useState([]);

  useEffect(() => {
    // Update time every second
    const timer = setInterval(() => setTime(new Date()), 1000);

    // Fetch weather every 10 minutes
    fetchWeather();
    const weatherInterval = setInterval(fetchWeather, 600000);

    return () => {
      clearInterval(timer);
      clearInterval(weatherInterval);
    };
  }, []);

  const fetchWeather = async () => {
    const response = await fetch('/api/weather');
    const data = await response.json();
    setWeather(data);
  };

  return (
    <div className="mirror-container">
      <div className="top-left">
        <div className="time">{time.toLocaleTimeString()}</div>
        <div className="date">{time.toLocaleDateString()}</div>
      </div>

      <div className="top-right">
        {weather && (
          <div className="weather">
            <div className="temp">{weather.temp}°C</div>
            <div className="condition">{weather.condition}</div>
          </div>
        )}
      </div>

      <div className="bottom-left">
        <div className="calendar">
          <h3>Today's Schedule</h3>
          {calendar.map((event) => (
            <div key={event.id} className="event">
              <span>{event.time}</span>
              <span>{event.title}</span>
            </div>
          ))}
        </div>
      </div>

      <div className="center">{/* Wellness insights go here */}</div>
    </div>
  );
};

export default MirrorUI;

/* Mirror UI must have black background for visibility */
.mirror-container {
  background: #000;
  color: #fff;
  font-family: 'Roboto', sans-serif;
  height: 100vh;
  width: 100vw;
  display: grid;
  grid-template-areas:
    'top-left top-right'
    'center center'
    'bottom-left bottom-right';
  grid-template-rows: 1fr 2fr 1fr;
  grid-template-columns: 1fr 1fr;
  padding: 40px;
}

.top-left {
  grid-area: top-left;
}
.top-right {
  grid-area: top-right;
  text-align: right;
}
.center {
  grid-area: center;
}
.bottom-left {
  grid-area: bottom-left;
}

.time {
  font-size: 4rem;
  font-weight: 300;
}

.date {
  font-size: 1.5rem;
  opacity: 0.8;
}

.weather .temp {
  font-size: 3rem;
}

import tensorflow as tf
from datetime import datetime, time as dt_time

class WellnessEngine:
    def __init__(self):
        self.user_profile = self.load_user_profile()

    def get_recommendations(self) -> dict:
        """Generate personalized wellness recommendations"""
        current_time = datetime.now()

        recommendations = {
            'hydration': self.check_hydration(current_time),
            'posture': self.check_posture_reminder(current_time),
            'break': self.check_break_needed(current_time),
            'sleep': self.check_sleep_quality(),
        }

        return recommendations

    def check_hydration(self, current_time: datetime) -> dict:
        """Remind user to drink water"""
        last_drink = self.user_profile.get('last_hydration')

        if not last_drink or (current_time - last_drink).seconds > 3600:
            return {
                'show': True,
                'message': '💧 Time to hydrate! Drink a glass of water.',
                'priority': 'medium'
            }
        return {'show': False}

    def check_posture_reminder(self, current_time: datetime) -> dict:
        """Remind about posture every 30 minutes"""
        if current_time.minute in [0, 30]:
            return {
                'show': True,
                'message': '🧘 Check your posture! Sit up straight.',
                'priority': 'low'
            }
        return {'show': False}

    def check_break_needed(self, current_time: datetime) -> dict:
        """Suggest breaks based on work duration"""
        work_duration = self.calculate_work_duration()

        if work_duration > 90:  # 90 minutes
            return {
                'show': True,
                'message': '☕ Take a 5-minute break. Your brain will thank you!',
                'priority': 'high'
            }
        return {'show': False}

    def check_sleep_quality(self) -> dict:
        """Analyze sleep patterns"""
        avg_sleep = self.user_profile.get('avg_sleep_hours', 7)

        if avg_sleep < 6:
            return {
                'show': True,
                'message': '😴 You averaged less than 6 hours of sleep. Consider sleeping earlier tonight.',
                'priority': 'high'
            }
        return {'show': False}

// Node.js API endpoint for smart home
const express = require('express');
const axios = require('axios');

const app = express();

app.get('/api/smarthome/lights', async (req, res) => {
  try {
    const response = await axios.get('http://homeassistant.local:8123/api/states/light.living_room', {
      headers: {
        Authorization: `Bearer ${process.env.HA_TOKEN}`,
      },
    });

    res.json({
      state: response.data.state,
      brightness: response.data.attributes.brightness,
    });
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch lights' });
  }
});

app.post('/api/smarthome/lights/toggle', async (req, res) => {
  try {
    await axios.post(
      'http://homeassistant.local:8123/api/services/light/toggle',
      { entity_id: 'light.living_room' },
      {
        headers: {
          Authorization: `Bearer ${process.env.HA_TOKEN}`,
        },
      }
    );

    res.json({ success: true });
  } catch (error) {
    res.status(500).json({ error: 'Failed to toggle lights' });
  }
});

# Chromium flags for better performance
chromium-browser --kiosk --disable-infobars \
  --enable-features=WebRTCPipeWireCapturer \
  --enable-accelerated-2d-canvas \
  --enable-gpu-rasterization \
  http://localhost:3000

async function fetchWithRetry(url, options = {}, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url, options);
      if (response.ok) return response;
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, i)));
    }
  }
}

import tflite_runtime.interpreter as tflite
import numpy as np
import sounddevice as sd

class WakeWordDetector:
    def __init__(self, model_path: str):
        self.interpreter = tflite.Interpreter(model_path=model_path)
        self.interpreter.allocate_tensors()

        self.input_details = self.interpreter.get_input_details()
        self.output_details = self.interpreter.get_output_details()

    def listen(self, duration: float = 1.0, sample_rate: int = 16000):
        """Record audio for specified duration"""
        audio = sd.rec(
            int(duration * sample_rate),
            samplerate=sample_rate,
            channels=1,
            dtype=np.float32
        )
        sd.wait()
        return audio

    def detect(self, audio: np.ndarray) -> bool:
        """Detect if wake word is present in audio"""
        # Preprocess audio
        audio = self.preprocess(audio)

        # Run inference
        self.interpreter.set_tensor(self.input_details[0]['index'], audio)
        self.interpreter.invoke()
        output = self.interpreter.get_tensor(self.output_details[0]['index'])

        # Check confidence
        confidence = output[0][1]  # Probability of wake word
        return confidence > 0.8

    def preprocess(self, audio: np.ndarray) -> np.ndarray:
        """Convert audio to format expected by model"""
        # Normalize
        audio = audio / np.max(np.abs(audio))

        # Convert to spectrogram (model-specific)
        # ... (simplified for brevity)

        return audio.reshape(1, -1).astype(np.float32)

# Usage
detector = WakeWordDetector('models/wake_word.tflite')

while True:
    audio = detector.listen()
    if detector.detect(audio):
        print("Wake word detected!")
        # Trigger voice command mode