# main.py - 智能灯光控制器
import network
import socket
import json
from machine import Pin, PWM, ADC
import time
import uasyncio as asyncio

class SmartLightSystem:
    def __init__(self):
        # WiFi配置
        self.WIFI_SSID = "你的WiFi"
        self.WIFI_PASSWORD = "你的密码"
  
        # 设备初始化
        self.lights = {
            'living_room': PWM(Pin(2), freq=1000),  # 客厅调光LED
            'bedroom': Pin(4, Pin.OUT),             # 卧室开关灯
            'kitchen': Pin(5, Pin.OUT)              # 厨房开关灯
        }
  
        # 传感器初始化
        self.light_sensor = ADC(Pin(32))
        self.light_sensor.atten(ADC.ATTN_11DB)
        self.motion_sensor = Pin(15, Pin.IN)
  
        # 系统状态
        self.auto_mode = True
        self.light_intensity = 500  # 默认亮度
        self.motion_timeout = 0
  
        # 连接WiFi
        self.connect_wifi()
  
    def connect_wifi(self):
        """连接WiFi"""
        wlan = network.WLAN(network.STA_IF)
        wlan.active(True)
  
        if not wlan.isconnected():
            print('连接WiFi...')
            wlan.connect(self.WIFI_SSID, self.WIFI_PASSWORD)
    
            for _ in range(20):
                if wlan.isconnected():
                    break
                time.sleep(1)
  
        if wlan.isconnected():
            print('网络配置:', wlan.ifconfig())
            return True
        return False
  
    def read_light_sensor(self):
        """读取光照强度"""
        raw_value = self.light_sensor.read()
        # 转换为百分比 (0-100)
        light_level = max(0, min(100, (4095 - raw_value) / 4095 * 100))
        return light_level
  
    def check_motion(self):
        """检测人体移动"""
        return self.motion_sensor.value() == 1
  
    def set_light_brightness(self, light_name, brightness):
        """设置灯光亮度 (0-1023)"""
        if light_name in self.lights:
            if isinstance(self.lights[light_name], PWM):
                self.lights[light_name].duty(brightness)
            else:
                self.lights[light_name].value(1 if brightness > 0 else 0)
  
    def auto_light_control(self):
        """自动灯光控制逻辑"""
        if not self.auto_mode:
            return
  
        light_level = self.read_light_sensor()
        has_motion = self.check_motion()
  
        # 自动调光逻辑
        if light_level < 30:  # 环境太暗
            if has_motion:
                # 有人且环境暗，开启灯光
                target_brightness = int((30 - light_level) / 30 * 1023)
                self.set_light_brightness('living_room', target_brightness)
                self.motion_timeout = time.time() + 300  # 5分钟超时
            else:
                # 无人移动，检查超时
                if time.time() > self.motion_timeout:
                    self.set_light_brightness('living_room', 0)
        else:
            # 环境足够亮，关闭灯光
            self.set_light_brightness('living_room', 0)
  
    async def web_control_handler(self, reader, writer):
        """Web控制处理器"""
        request = await reader.read(1024)
        request_str = request.decode('utf-8')
  
        # 解析HTTP请求
        if 'GET / ' in request_str or 'GET /index' in request_str:
            # 返回控制页面
            html = self.generate_control_page()
            response = f"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n{html}"
  
        elif 'GET /status' in request_str:
            # 返回系统状态
            status = {
                'auto_mode': self.auto_mode,
                'light_level': self.read_light_sensor(),
                'motion_detected': self.check_motion(),
                'lights': {
                    name: self.lights[name].duty() if isinstance(self.lights[name], PWM) 
                    else self.lights[name].value() 
                    for name in self.lights
                }
            }
            response = f"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n{json.dumps(status)}"
  
        elif 'POST /control' in request_str:
            # 处理控制命令
            lines = request_str.split('\r\n')
            for line in lines:
                if line.startswith('{'):
                    try:
                        command = json.loads(line)
                        if 'light' in command and 'brightness' in command:
                            self.set_light_brightness(command['light'], command['brightness'])
                        if 'auto_mode' in command:
                            self.auto_mode = command['auto_mode']
                    except:
                        pass
    
            response = "HTTP/1.1 200 OK\r\n\r\nOK"
  
        else:
            response = "HTTP/1.1 404 Not Found\r\n\r\nNot Found"
  
        await writer.awrite(response.encode('utf-8'))
        await writer.aclose()
  
    def generate_control_page(self):
        """生成Web控制页面"""
        return """
        <!DOCTYPE html>
        <html>
        <head>
            <title>智能灯光控制系统</title>
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <style>
                body { font-family: Arial; margin: 20px; background: #f5f5f5; }
                .card { background: white; padding: 20px; margin: 10px 0; border-radius: 10px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
                .slider { width: 100%; margin: 10px 0; }
                .switch { position: relative; display: inline-block; width: 60px; height: 34px; }
                .switch input { opacity: 0; width: 0; height: 0; }
                .slider { position: absolute; cursor: pointer; top: 0; left: 0; right: 0; bottom: 0; background-color: #ccc; transition: .4s; border-radius: 34px; }
                .slider:before { position: absolute; content: ""; height: 26px; width: 26px; left: 4px; bottom: 4px; background-color: white; transition: .4s; border-radius: 50%; }
                input:checked + .slider { background-color: #2196F3; }
                input:checked + .slider:before { transform: translateX(26px); }
                button { background: #2196F3; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 5px; }
            </style>
        </head>
        <body>
            <h1>🏠 智能灯光控制</h1>
    
            <div class="card">
                <h3>🤖 自动模式</h3>
                <label class="switch">
                    <input type="checkbox" id="autoMode" onchange="toggleAutoMode()">
                    <span class="slider"></span>
                </label>
                <span id="autoStatus">关闭</span>
            </div>
    
            <div class="card">
                <h3>💡 客厅调光LED</h3>
                <input type="range" min="0" max="1023" value="500" class="slider" id="livingRoomSlider" onchange="setBrightness('living_room', this.value)">
                <span id="livingRoomValue">500</span>
            </div>
    
            <div class="card">
                <h3>🛏️ 卧室灯光</h3>
                <button onclick="toggleLight('bedroom')">开关</button>
                <span id="bedroomStatus">关闭</span>
            </div>
    
            <div class="card">
                <h3>🔍 系统状态</h3>
                <p>光照强度: <span id="lightLevel">--</span>%</p>
                <p>人体感应: <span id="motionStatus">--</span></p>
            </div>
    
            <script>
                function setBrightness(light, value) {
                    fetch('/control', {
                        method: 'POST',
                        body: JSON.stringify({light: light, brightness: parseInt(value)})
                    });
                    document.getElementById(light + 'Value').textContent = value;
                }
        
                function toggleLight(light) {
                    const statusElem = document.getElementById(light + 'Status');
                    const current = statusElem.textContent === '开启' ? 0 : 1;
                    setBrightness(light, current ? 1 : 0);
                    statusElem.textContent = current ? '开启' : '关闭';
                }
        
                function toggleAutoMode() {
                    const checkbox = document.getElementById('autoMode');
                    const statusElem = document.getElementById('autoStatus');
                    fetch('/control', {
                        method: 'POST',
                        body: JSON.stringify({auto_mode: checkbox.checked})
                    });
                    statusElem.textContent = checkbox.checked ? '开启' : '关闭';
                }
        
                // 定期更新状态
                setInterval(() => {
                    fetch('/status')
                        .then(r => r.json())
                        .then(data => {
                            document.getElementById('lightLevel').textContent = data.light_level.toFixed(1);
                            document.getElementById('motionStatus').textContent = data.motion_detected ? '检测到移动' : '无移动';
                            document.getElementById('autoMode').checked = data.auto_mode;
                            document.getElementById('autoStatus').textContent = data.auto_mode ? '开启' : '关闭';
                        });
                }, 2000);
            </script>
        </body>
        </html>
        """
  
    async def main_loop(self):
        """主循环"""
        # 启动Web服务器
        server = await asyncio.start_server(self.web_control_handler, "0.0.0.0", 80)
        print("Web服务器已启动在端口80")
  
        # 主控制循环
        while True:
            self.auto_light_control()
            await asyncio.sleep(1)

# 启动系统
system = SmartLightSystem()
asyncio.run(system.main_loop())

# temperature_control.py
import dht
import machine
import time
import network
import urequests as requests

class SmartThermostat:
    def __init__(self):
        # 传感器
        self.indoor_sensor = dht.DHT22(machine.Pin(4))
        self.outdoor_sensor = dht.DHT22(machine.Pin(5))
  
        # 执行器
        self.ac_relay = machine.Pin(2, machine.Pin.OUT)      # 空调
        self.humidifier_relay = machine.Pin(15, machine.Pin.OUT)  # 加湿器
        self.heater_relay = machine.Pin(16, machine.Pin.OUT)      # 加热器
  
        # 温度设定
        self.target_temp = 24.0    # 目标温度
        self.target_humidity = 50  # 目标湿度
        self.temp_tolerance = 1.0  # 温度容差
        self.humidity_tolerance = 5  # 湿度容差
  
        # 连接WiFi
        self.connect_wifi()
  
    def read_sensors(self):
        """读取所有传感器数据"""
        try:
            self.indoor_sensor.measure()
            indoor_temp = self.indoor_sensor.temperature()
            indoor_humidity = self.indoor_sensor.humidity()
        except:
            indoor_temp = None
            indoor_humidity = None
  
        try:
            self.outdoor_sensor.measure()
            outdoor_temp = self.outdoor_sensor.temperature()
            outdoor_humidity = self.outdoor_sensor.humidity()
        except:
            outdoor_temp = None
            outdoor_humidity = None
  
        return {
            'indoor_temp': indoor_temp,
            'indoor_humidity': indoor_humidity,
            'outdoor_temp': outdoor_temp,
            'outdoor_humidity': outdoor_humidity
        }
  
    def climate_control(self, sensor_data):
        """气候控制逻辑"""
        indoor_temp = sensor_data['indoor_temp']
        indoor_humidity = sensor_data['indoor_humidity']
  
        if indoor_temp is None or indoor_humidity is None:
            return  # 传感器读取失败
  
        # 温度控制
        if indoor_temp > self.target_temp + self.temp_tolerance:
            # 太热，开空调
            self.ac_relay.on()
            self.heater_relay.off()
        elif indoor_temp < self.target_temp - self.temp_tolerance:
            # 太冷，开加热器
            self.heater_relay.on()
            self.ac_relay.off()
        else:
            # 温度合适，关闭温控设备
            self.ac_relay.off()
            self.heater_relay.off()
  
        # 湿度控制
        if indoor_humidity > self.target_humidity + self.humidity_tolerance:
            # 太湿，关闭加湿器（如果有除湿机可以开启）
            self.humidifier_relay.off()
        elif indoor_humidity < self.target_humidity - self.humidity_tolerance:
            # 太干，开启加湿器
            self.humidifier_relay.on()
        else:
            self.humidifier_relay.off()
  
    def energy_saving_mode(self, sensor_data):
        """节能模式逻辑"""
        outdoor_temp = sensor_data['outdoor_temp']
        indoor_temp = sensor_data['indoor_temp']
  
        if outdoor_temp is None or indoor_temp is None:
            return
  
        # 如果室外温度适宜，建议开窗通风
        if 20 <= outdoor_temp <= 26 and abs(outdoor_temp - self.target_temp) < 2:
            return "建议开窗通风，节省能源"
  
        # 根据室内外温差调整目标温度
        temp_diff = outdoor_temp - indoor_temp
  
        if temp_diff > 5:  # 室外比室内热很多
            # 稍微提高目标温度节省空调能耗
            self.target_temp = min(26, self.target_temp + 1)
            return f"节能模式：目标温度调整为{self.target_temp}°C"
  
        return None
  
    def send_notification(self, message):
        """发送通知（需要配置推送服务）"""
        try:
            # 示例：使用Pushbullet推送
            # 实际使用时需要注册API
            pass
        except:
            print(f"通知发送失败: {message}")
  
    def run(self):
        """主运行循环"""
        print("智能温控系统启动")
  
        while True:
            # 读取传感器数据
            sensor_data = self.read_sensors()
            print(f"室内: {sensor_data['indoor_temp']}°C, {sensor_data['indoor_humidity']}%")
            print(f"室外: {sensor_data['outdoor_temp']}°C, {sensor_data['outdoor_humidity']}%")
    
            # 执行控制逻辑
            self.climate_control(sensor_data)
    
            # 节能建议
            energy_advice = self.energy_saving_mode(sensor_data)
            if energy_advice:
                print(f"💡 {energy_advice}")
                self.send_notification(energy_advice)
    
            # 异常检测
            if sensor_data['indoor_temp'] and sensor_data['indoor_temp'] > 35:
                self.send_notification("⚠️ 警告：室内温度过高！")
            if sensor_data['indoor_humidity'] and sensor_data['indoor_humidity'] > 80:
                self.send_notification("⚠️ 警告：室内湿度过高！")
    
            time.sleep(60)  # 每分钟检查一次

# 启动系统
thermostat = SmartThermostat()
thermostat.run()

# security_system.py
import camera
import network
import machine
import time
import urequests as requests
import ujson as json

class SmartSecuritySystem:
    def __init__(self):
        # 安防传感器
        self.pir_sensors = [
            machine.Pin(12, machine.Pin.IN),  # 门口
            machine.Pin(13, machine.Pin.IN)   # 窗户
        ]
        self.door_sensor = machine.Pin(14, machine.Pin.IN)  # 门磁
  
        # 报警设备
        self.buzzer = machine.Pin(4, machine.Pin.OUT)
        self.alarm_led = machine.Pin(2, machine.Pin.OUT)
  
        # 系统状态
        self.armed = False  # 布防状态
        self.alarm_triggered = False
        self.last_trigger_time = 0
  
        # 初始化摄像头
        try:
            camera.init(0, format=camera.JPEG)
            print("摄像头初始化成功")
        except Exception as e:
            print(f"摄像头初始化失败: {e}")
  
        self.connect_wifi()
  
    def check_sensors(self):
        """检查所有传感器状态"""
        sensor_status = {
            'pir1': self.pir_sensors[0].value() == 1,
            'pir2': self.pir_sensors[1].value() == 1,
            'door': self.door_sensor.value() == 0  # 门磁通常常闭
        }
        return sensor_status
  
    def capture_image(self):
        """捕获图像"""
        try:
            buf = camera.capture()
            return buf
        except Exception as e:
            print(f"图像捕获失败: {e}")
            return None
  
    def trigger_alarm(self, sensor_type, location):
        """触发报警"""
        if not self.armed or self.alarm_triggered:
            return
  
        current_time = time.time()
        if current_time - self.last_trigger_time < 300:  # 5分钟内不重复报警
            return
  
        print(f"🚨 报警触发！位置: {location}, 类型: {sensor_type}")
  
        # 声光报警
        self.buzzer.on()
        self.alarm_led.on()
  
        # 捕获现场图像
        image_data = self.capture_image()
  
        # 发送报警通知
        self.send_alert(sensor_type, location, image_data)
  
        self.alarm_triggered = True
        self.last_trigger_time = current_time
  
        # 30秒后停止声音报警（灯光保持）
        machine.Timer(-1).init(period=30000, mode=machine.Timer.ONE_SHOT, 
                              callback=lambda t: self.buzzer.off())
  
    def send_alert(self, sensor_type, location, image_data=None):
        """发送报警通知"""
        message = f"🚨 家庭安防报警\n位置: {location}\n类型: {sensor_type}\n时间: {time.ctime()}"
  
        try:
            # 发送到手机APP（需要配置Webhook）
            if image_data:
                # 如果有图像，可以上传到图床或直接发送
                pass
    
            # 示例：发送到Discord或Telegram
            webhook_url = "你的Webhook地址"
            payload = {
                "content": message,
                "username": "家庭安防系统"
            }
    
            response = requests.post(webhook_url, json=payload)
            print(f"报警通知发送状态: {response.status_code}")
    
        except Exception as e:
            print(f"通知发送失败: {e}")
  
    def arm_system(self):
        """布防系统"""
        self.armed = True
        self.alarm_triggered = False
        print("系统已布防")
        self.send_notification("✅ 安防系统已布防")
  
    def disarm_system(self):
        """撤防系统"""
        self.armed = False
        self.alarm_triggered = False
        self.buzzer.off()
        self.alarm_led.off()
        print("系统已撤防")
        self.send_notification("🔓 安防系统已撤防")
  
    def monitoring_loop(self):
        """监控循环"""
        print("开始安防监控...")
  
        while True:
            if self.armed:
                sensor_status = self.check_sensors()
        
                # 检查人体感应
                if sensor_status['pir1']:
                    self.trigger_alarm("人体移动", "门口区域")
                elif sensor_status['pir2']:
                    self.trigger_alarm("人体移动", "窗户区域")
        
                # 检查门磁
                if sensor_status['door']:
                    self.trigger_alarm("门窗异常", "主入口")
    
            time.sleep(0.5)  # 快速响应

# Web控制接口（简化版）
def web_control():
    """Web控制接口"""
    security_system = SmartSecuritySystem()
  
    def handle_request(request):
        if 'arm' in request:
            security_system.arm_system()
            return "系统布防成功"
        elif 'disarm' in request:
            security_system.disarm_system()
            return "系统撤防成功"
        elif 'status' in request:
            status = "布防" if security_system.armed else "撤防"
            return f"系统状态: {status}"
  
        return "未知命令"
  
    return handle_request

# voice_control.py
import network
import socket
import json
import machine
from machine import Pin, PWM
import time

class VoiceControlSystem:
    def __init__(self):
        # 语音命令映射
        self.commands = {
            '开灯': self.turn_on_light,
            '关灯': self.turn_off_light,
            '开空调': self.turn_on_ac,
            '关空调': self.turn_off_ac,
            '温度调高': self.temp_up,
            '温度调低': self.temp_down,
            '场景模式': self.scene_mode,
            '晚安模式': self.goodnight_mode
        }
  
        # 设备控制
        self.devices = {
            'living_room_light': Pin(2, Pin.OUT),
            'bedroom_light': Pin(4, Pin.OUT),
            'ac_unit': Pin(5, Pin.OUT),
            'rgb_led': PWM(Pin(6), freq=1000)
        }
  
        # 系统状态
        self.current_temp = 24
        self.current_scene = "normal"
  
        # 连接语音识别服务（需要外部API）
        self.setup_voice_service()
  
    def process_voice_command(self, audio_data):
        """处理语音命令"""
        # 这里需要调用语音识别API
        # 示例使用简单的文本输入模拟
  
        recognized_text = self.recognize_speech(audio_data)
  
        if recognized_text:
            print(f"识别到命令: {recognized_text}")
            return self.execute_command(recognized_text)
  
        return "未识别到有效命令"
  
    def recognize_speech(self, audio_data):
        """语音识别（模拟）"""
        # 实际项目中需要调用如百度语音、讯飞等API
        # 这里返回模拟的识别结果
        return "开灯"  # 模拟识别结果
  
    def execute_command(self, command_text):
        """执行语音命令"""
        for cmd_pattern, cmd_func in self.commands.items():
            if cmd_pattern in command_text:
                try:
                    result = cmd_func()
                    self.voice_response(f"已执行{cmd_pattern}")
                    return result
                except Exception as e:
                    self.voice_response(f"执行失败: {e}")
                    return False
  
        self.voice_response("未找到对应命令")
        return False
  
    def voice_response(self, message):
        """语音响应"""
        print(f"语音响应: {message}")
        # 实际项目中可以调用TTS服务播报
  
    # 具体命令实现
    def turn_on_light(self):
        self.devices['living_room_light'].on()
        return "客厅灯已打开"
  
    def turn_off_light(self):
        self.devices['living_room_light'].off()
        return "客厅灯已关闭"
  
    def turn_on_ac(self):
        self.devices['ac_unit'].on()
        return "空调已打开"
  
    def turn_off_ac(self):
        self.devices['ac_unit'].off()
        return "空调已关闭"
  
    def temp_up(self):
        self.current_temp += 1
        return f"温度已调至{self.current_temp}度"
  
    def temp_down(self):
        self.current_temp -= 1
        return f"温度已调至{self.current_temp}度"
  
    def scene_mode(self):
        scenes = ["阅读模式", "影院模式", "聚会模式"]
        current_index = scenes.index(self.current_scene) if self.current_scene in scenes else 0
        next_scene = scenes[(current_index + 1) % len(scenes)]
  
        self.apply_scene(next_scene)
        return f"已切换到{next_scene}"
  
    def goodnight_mode(self):
        """晚安模式：关闭所有灯光，调整温度"""
        for device in self.devices.values():
            if hasattr(device, 'off'):
                device.off()
  
        self.current_temp = 22  # 睡眠适宜温度
        return "晚安模式已启动，祝您晚安"
  
    def apply_scene(self, scene_name):
        """应用场景模式"""
        self.current_scene = scene_name
  
        if scene_name == "阅读模式":
            self.devices['living_room_light'].on()
            self.devices['rgb_led'].duty(300)  # 暖白光
        elif scene_name == "影院模式":
            self.devices['living_room_light'].off()
            self.devices['rgb_led'].duty(50)   # 低亮度
        elif scene_name == "聚会模式":
            self.devices['living_room_light'].on()
            # RGB LED可以设置彩色效果
            self.start_party_lights()
  
    def start_party_lights(self):
        """派对灯光效果"""
        def color_cycle():
            for i in range(0, 1024, 10):
                self.devices['rgb_led'].duty(i)
                time.sleep(0.1)
  
        # 在实际项目中应该用异步处理
        color_cycle()

# 使用示例
voice_system = VoiceControlSystem()

# 模拟语音输入
def test_voice_commands():
    commands = ["开灯", "关灯", "温度调高", "晚安模式"]
  
    for cmd in commands:
        print(f"语音输入: {cmd}")
        result = voice_system.execute_command(cmd)
        print(f"系统响应: {result}")
        print("-" * 30)
        time.sleep(2)

# test_voice_commands()

# home_assistant.py - 智能家居集成平台
import uasyncio as asyncio
import network
import json

class HomeAssistant:
    def __init__(self):
        self.systems = {
            'lighting': SmartLightSystem(),
            'climate': SmartThermostat(),
            'security': SmartSecuritySystem(),
            'voice': VoiceControlSystem()
        }
  
        self.scenes = {
            'home': self.scene_home,
            'away': self.scene_away,
            'sleep': self.scene_sleep,
            'wakeup': self.scene_wakeup
        }
  
    async def scene_home(self):
        """回家场景"""
        self.systems['lighting'].set_light_brightness('living_room', 700)
        self.systems['climate'].target_temp = 24
        self.systems['security'].disarm_system()
        return "回家模式已启动"
  
    async def scene_away(self):
        """离家场景"""
        self.systems['lighting'].set_light_brightness('living_room', 0)
        self.systems['climate'].target_temp = 28  # 节能温度
        self.systems['security'].arm_system()
        return "离家模式已启动"
  
    async def scene_sleep(self):
        """睡眠场景"""
        self.systems['lighting'].set_light_brightness('living_room', 0)
        self.systems['lighting'].set_light_brightness('bedroom', 100)  # 夜灯
        self.systems['climate'].target_temp = 22
        self.systems['security'].arm_system()
        return "睡眠模式已启动"
  
    async def scene_wakeup(self):
        """唤醒场景"""
        # 模拟日出，灯光渐亮
        for brightness in range(0, 800, 50):
            self.systems['lighting'].set_light_brightness('bedroom', brightness)
            await asyncio.sleep(1)
  
        self.systems['climate'].target_temp = 24
        return "唤醒模式已启动"
  
    async def execute_scene(self, scene_name):
        """执行场景"""
        if scene_name in self.scenes:
            return await self.scenes[scene_name]()
        return "未知场景"
  
    async def system_status(self):
        """获取所有系统状态"""
        status = {}
        for name, system in self.systems.items():
            # 这里需要每个系统实现status方法
            if hasattr(system, 'get_status'):
                status[name] = system.get_status()
        return status

# 创建统一管理平台
assistant = HomeAssistant()

# 使用示例
async def main():
    # 启动回家场景
    result = await assistant.execute_scene('home')
    print(result)
  
    # 获取系统状态
    status = await assistant.system_status()
    print("系统状态:", json.dumps(status))

# asyncio.run(main())