用Python玩转智能家居：5分钟实现手机蓝牙控制树莓派

用Python构建你的智能家居控制中枢：从蓝牙通信到硬件联动实战

想象一下，周末的清晨，你躺在沙发上，只需在手机屏幕上轻轻一点，客厅的灯光缓缓亮起，空调自动调到舒适的温度，音响开始播放你最喜欢的音乐。这不再是科幻电影中的场景，而是每个技术爱好者都能亲手实现的智能家居体验。今天，我将带你深入探索如何用Python和蓝牙技术，打造一个完全由你掌控的家庭自动化系统。

对于许多创客和智能家居爱好者来说，树莓派是理想的家庭服务器选择，而蓝牙则是连接手机与这些硬件设备的完美桥梁。与Wi-Fi相比，蓝牙连接更加直接、功耗更低，特别适合控制开关、传感器等简单设备。但市面上大多数教程要么过于简单，要么陷入复杂的底层协议细节，让初学者望而却步。

在这篇文章中，我将分享一套经过实战检验的完整方案，从蓝牙通信的基础原理到实际项目部署，涵盖了你需要知道的所有关键细节。无论你是想控制一盏智能灯，还是构建一个完整的家庭监控系统，这里的内容都能为你提供坚实的技术基础。

1. 智能家居蓝牙技术栈深度解析

在开始编写代码之前，我们需要理解蓝牙技术在智能家居中的应用场景和技术选择。蓝牙技术经过多年发展，已经形成了多种不同的协议栈，每种都有其特定的适用场景。

1.1 经典蓝牙与低功耗蓝牙的技术抉择

当你准备为智能家居项目选择蓝牙方案时，首先面临的就是经典蓝牙（Bluetooth Classic）和低功耗蓝牙（Bluetooth Low Energy，简称BLE）之间的选择。这两种技术虽然都叫"蓝牙"，但在设计理念和应用场景上有着本质区别。

经典蓝牙主要设计用于持续的数据流传输，比如音频传输、文件传输等场景。它的特点是带宽较高（最高可达3Mbps），但功耗也相对较大。在智能家居中，经典蓝牙适合那些需要传输较大数据量或需要稳定持续连接的应用，比如：

• 音频设备控制（音响、耳机）
• 视频流传输
• 需要高速数据传输的传感器

低功耗蓝牙则是为物联网设备量身定制的技术，它的设计重点是极低的功耗和快速的连接建立。BLE设备在大部分时间处于睡眠状态，只在需要传输数据时才短暂唤醒。这使得BLE设备可以使用纽扣电池工作数月甚至数年。典型的BLE智能家居应用包括：

• 温湿度传感器
• 门窗开关传感器
• 智能灯泡和开关
• 可穿戴设备

为了更清晰地展示两者的区别，我整理了一个对比表格：

对于大多数智能家居控制场景，特别是手机控制树莓派这类应用，我推荐使用经典蓝牙的RFCOMM协议。原因很简单：RFCOMM模拟了传统的串行端口，编程模型简单直观，类似于网络Socket编程，学习曲线平缓。而且树莓派和手机都原生支持RFCOMM，不需要额外的硬件适配。

1.2 Python蓝牙生态现状与库选择

Python的蓝牙开发生态在过去几年经历了显著变化。早期最流行的库是PyBluez，但这个库已经多年没有维护，在Python 3.8+和现代操作系统上安装经常遇到各种问题。我在实际项目中踩过不少坑，最终找到了更可靠的替代方案。

目前主流的Python蓝牙库可以分为以下几类：

跨平台解决方案：

• bleak：这是目前最活跃的BLE开发库，支持Windows、macOS、Linux全平台。它的API设计现代且易于使用，特别适合BLE设备开发。
• pybluez2：PyBluez的现代分支版本，解决了原版的许多兼容性问题，支持经典蓝牙开发。

平台特定方案：

• Linux/树莓派：可以直接使用bluez的DBus接口，或者通过socket模块直接操作
• Windows：从Python 3.9开始，标准库的socket模块增加了蓝牙支持

硬件专用库：

• bluepy：专门针对树莓派和Linux的BLE库
• RPi.GPIO + 蓝牙模块：通过串口控制蓝牙模块的经典方案

对于我们的智能家居控制项目，我推荐使用pybluez2进行经典蓝牙开发。它不仅解决了原版PyBluez的安装问题，而且API保持兼容，现有的PyBluez代码几乎可以无缝迁移。下面是一个简单的安装示例：

# 安装pybluez2
pip install pybluez2

# 验证安装
python -c "import bluetooth; print('蓝牙库版本:', bluetooth.__version__)"

如果你在安装过程中遇到问题，特别是Windows平台，可能需要先安装一些系统依赖：

# Windows可能需要安装Visual C++ Build Tools
# 可以从这里下载：https://visualstudio.microsoft.com/visual-cpp-build-tools/

# Linux/树莓派安装系统依赖
sudo apt-get update
sudo apt-get install libbluetooth-dev python3-dev

注意：在树莓派上开发时，请确保蓝牙服务正常运行。可以通过sudo systemctl status bluetooth检查服务状态，如果未运行，使用sudo systemctl start bluetooth启动服务。

2. 构建蓝牙通信核心引擎

理解了技术选型后，我们现在开始构建智能家居系统的通信核心。这一部分将实现一个稳定可靠的蓝牙通信层，它负责处理设备发现、连接建立、数据传输和异常处理。

2.1 设备发现与配对机制

在蓝牙通信中，设备发现是第一步。与Wi-Fi不同，蓝牙设备默认是不可见的，需要主动进入可发现模式才能被其他设备扫描到。这个过程在智能家居场景中尤为重要，因为我们需要让树莓派能够被手机发现并连接。

让我们先实现一个完整的设备发现模块。这个模块不仅要能发现设备，还要能过滤出我们关心的设备类型，并处理各种异常情况：

import bluetooth
import time
from typing import List, Dict, Optional

class BluetoothDiscoverer:
    """蓝牙设备发现器"""
    
    def __init__(self, duration: int = 8):
        """
        初始化发现器
        
        Args:
            duration: 发现过程持续时间（秒）
        """
        self.duration = duration
        self.discovered_devices = []
        
    def discover_devices(self, device_filter: Optional[List[str]] = None) -> List[Dict]:
        """
        发现周围的蓝牙设备
        
        Args:
            device_filter: 设备名称过滤列表，只返回包含这些关键词的设备
            
        Returns:
            设备信息列表，每个设备包含name和address
        """
        print(f"开始蓝牙设备发现，持续{self.duration}秒...")
        
        try:
            # 执行设备发现
            devices = bluetooth.discover_devices(
                duration=self.duration,
                lookup_names=True,
                flush_cache=True
            )
            
            self.discovered_devices = []
            
            for addr, name in devices:
                device_info = {
                    'address': addr,
                    'name': name if name else '未知设备',
                    'services': []
                }
                
                # 如果指定了过滤器，检查设备名称
                if device_filter:
                    if not any(keyword in device_info['name'] for keyword in device_filter):
                        continue
                
                # 获取设备服务信息（可选，会增加发现时间）
                try:
                    services = bluetooth.find_service(address=addr)
                    device_info['services'] = [
                        {
                            'name': svc.get('name', '未知服务'),
                            'protocol': svc.get('protocol', '未知'),
                            'port': svc.get('port', 0)
                        }
                        for svc in services
                    ]
                except Exception as e:
                    print(f"获取设备 {name} 服务信息失败: {e}")
                
                self.discovered_devices.append(device_info)
                print(f"发现设备: {device_info['name']} ({addr})")
                
            print(f"发现完成，共找到 {len(self.discovered_devices)} 个设备")
            return self.discovered_devices
            
        except Exception as e:
            print(f"设备发现过程中发生错误: {e}")
            return []
    
    def find_device_by_name(self, device_name: str) -> Optional[Dict]:
        """通过设备名称查找特定设备"""
        for device in self.discovered_devices:
            if device['name'] == device_name:
                return device
        return None
    
    def find_device_by_address(self, address: str) -> Optional[Dict]:
        """通过设备地址查找特定设备"""
        for device in self.discovered_devices:
            if device['address'] == address:
                return device
        return None


# 使用示例
if __name__ == "__main__":
    discoverer = BluetoothDiscoverer(duration=10)
    
    # 只查找树莓派相关的设备
    raspberry_keywords = ["raspberry", "pi", "树莓派"]
    devices = discoverer.discover_devices(device_filter=raspberry_keywords)
    
    if devices:
        print("\n找到的树莓派设备:")
        for device in devices:
            print(f"  名称: {device['name']}")
            print(f"  地址: {device['address']}")
            print(f"  服务数: {len(device['services'])}")
            print()
    else:
        print("未找到符合条件的设备")

设备发现完成后，下一步是建立安全连接。在智能家居场景中，我们通常希望设备能够自动连接，而不需要每次手动配对。这可以通过两种方式实现：

1. 固定配对码：为所有设备设置相同的PIN码
2. 无配对连接：通过修改蓝牙配置允许特定设备无需配对直接连接

对于家庭内部使用的智能家居系统，我推荐使用第二种方式，因为它提供了更好的用户体验。下面是实现自动连接的代码：

import subprocess
import re

class BluetoothPairingManager:
    """蓝牙配对管理器"""
    
    @staticmethod
    def is_paired(address: str) -> bool:
        """检查设备是否已配对"""
        try:
            result = subprocess.run(
                ['bluetoothctl', 'info', address],
                capture_output=True,
                text=True,
                timeout=5
            )
            return 'Paired: yes' in result.stdout
        except Exception as e:
            print(f"检查配对状态失败: {e}")
            return False
    
    @staticmethod
    def pair_device(address: str, pin: str = "0000") -> bool:
        """配对设备"""
        try:
            # 启动配对过程
            subprocess.run(['bluetoothctl', 'pair', address], 
                          capture_output=True, text=True, timeout=10)
            
            # 输入PIN码（如果需要）
            subprocess.run(['bluetoothctl', 'trust', address], 
                          capture_output=True, text=True, timeout=5)
            
            print(f"设备 {address} 配对成功")
            return True
            
        except Exception as e:
            print(f"设备配对失败: {e}")
            return False
    
    @staticmethod
    def enable_auto_connect(address: str) -> bool:
        """启用设备自动连接"""
        try:
            # 修改蓝牙配置文件，允许自动连接
            config_path = "/etc/bluetooth/main.conf"
            
            with open(config_path, 'r') as f:
                config_content = f.read()
            
            # 检查并修改自动连接设置
            if 'AutoEnable=true' not in config_content:
                config_content = config_content.replace(
                    'AutoEnable=false',
                    'AutoEnable=true'
                )
                
                with open(config_path, 'w') as f:
                    f.write(config_content)
                
                # 重启蓝牙服务使配置生效
                subprocess.run(['sudo', 'systemctl', 'restart', 'bluetooth'], 
                              capture_output=True, text=True)
            
            print(f"已为设备 {address} 启用自动连接")
            return True
            
        except Exception as e:
            print(f"启用自动连接失败: {e}")
            return False

2.2 RFCOMM服务器与客户端实现

RFCOMM（Radio Frequency Communication）是蓝牙协议栈中模拟串行端口的部分，它为我们提供了类似TCP Socket的编程接口。在智能家居系统中，树莓派通常作为服务器运行，等待手机客户端的连接请求。

让我们先实现一个健壮的RFCOMM服务器：

import bluetooth
import threading
import queue
import json
from datetime import datetime
import logging

class SmartHomeBluetoothServer:
    """智能家居蓝牙服务器"""
    
    def __init__(self, server_name: str = "SmartHomeHub"):
        self.server_name = server_name
        self.uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"  # 唯一服务标识
        self.server_socket = None
        self.client_socket = None
        self.client_info = None
        self.is_running = False
        self.message_queue = queue.Queue()
        self.command_handlers = {}
        
        # 设置日志
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger("BluetoothServer")
        
        # 注册默认命令处理器
        self._register_default_handlers()
    
    def _register_default_handlers(self):
        """注册默认命令处理器"""
        self.register_handler("ping", self._handle_ping)
        self.register_handler("control", self._handle_control)
        self.register_handler("status", self._handle_status)
        self.register_handler("config", self._handle_config)
    
    def register_handler(self, command: str, handler):
        """注册命令处理器"""
        self.command_handlers[command] = handler
    
    def start(self, port: int = None):
        """启动蓝牙服务器"""
        try:
            # 创建RFCOMM Socket
            self.server_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
            
            # 绑定到任意地址和端口
            if port:
                self.server_socket.bind(("", port))
            else:
                self.server_socket.bind(("", bluetooth.PORT_ANY))
            
            # 获取实际绑定的端口
            actual_port = self.server_socket.getsockname()[1]
            self.logger.info(f"服务器绑定到端口: {actual_port}")
            
            # 开始监听
            self.server_socket.listen(1)
            
            # 广告服务，让客户端能够发现
            bluetooth.advertise_service(
                self.server_socket,
                self.server_name,
                service_id=self.uuid,
                service_classes=[self.uuid, bluetooth.SERIAL_PORT_CLASS],
                profiles=[bluetooth.SERIAL_PORT_PROFILE]
            )
            
            self.logger.info(f"蓝牙服务器 '{self.server_name}' 已启动，等待连接...")
            self.logger.info(f"服务UUID: {self.uuid}")
            self.logger.info(f"RFCOMM通道: {actual_port}")
            
            self.is_running = True
            
            # 启动连接接受线程
            accept_thread = threading.Thread(target=self._accept_connections)
            accept_thread.daemon = True
            accept_thread.start()
            
            # 启动消息处理线程
            process_thread = threading.Thread(target=self._process_messages)
            process_thread.daemon = True
            process_thread.start()
            
            return True
            
        exce