Python实例题：基于边缘计算的智能物联网系统

狐凄2025-06-23 2:08

目录

Python实例题

题目

问题描述

解题思路

关键代码框架

难点分析

扩展方向

Python实例题

题目

基于边缘计算的智能物联网系统

问题描述

开发一个基于边缘计算的智能物联网系统，包含以下功能：

  • 边缘设备管理：连接和管理大量物联网设备
  • 边缘计算节点：在边缘处理数据，减少云传输
  • 实时数据分析：实时处理和分析传感器数据
  • 智能决策：基于 AI 模型的自动化决策
  • 云边协同：边缘节点与云端的协同工作

解题思路

  • 设计边缘设备与边缘节点的通信协议
  • 开发边缘计算框架处理本地数据
  • 训练和部署轻量级 AI 模型到边缘节点
  • 实现云边数据同步和协同机制
  • 构建可视化界面监控系统状态

关键代码框架

python 复制代码 
# 边缘节点主程序
import asyncio
import json
import time
import logging
from typing import Dict, List, Any
import numpy as np
from sklearn.ensemble import IsolationForest
import paho.mqtt.client as mqtt
from sqlalchemy import create_engine, Column, Integer, Float, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import datetime

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# 配置
CONFIG = {
    'mqtt_broker': 'localhost',
    'mqtt_port': 1883,
    'mqtt_username': 'edge_node',
    'mqtt_password': 'edge_password',
    'data_topic': 'iot/data/#',
    'control_topic': 'iot/control/',
    'edge_id': 'edge-node-01',
    'db_url': 'sqlite:///edge_data.db',
    'anomaly_detection_window': 100,
    'sync_interval': 60  # 数据同步到云端的间隔(秒)
}

# 数据库模型
Base = declarative_base()

class SensorData(Base):
    __tablename__ = 'sensor_data'
    
    id = Column(Integer, primary_key=True)
    device_id = Column(String(50))
    sensor_type = Column(String(50))
    value = Column(Float)
    timestamp = Column(DateTime)
    processed = Column(Boolean, default=False)
    is_anomaly = Column(Boolean, default=False)

class AnomalyAlert(Base):
    __tablename__ = 'anomaly_alerts'
    
    id = Column(Integer, primary_key=True)
    device_id = Column(String(50))
    sensor_type = Column(String(50))
    value = Column(Float)
    timestamp = Column(DateTime)
    confidence = Column(Float)
    resolved = Column(Boolean, default=False)

# 初始化数据库
engine = create_engine(CONFIG['db_url'])
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# 异常检测模型
class AnomalyDetector:
    def __init__(self, window_size=100):
        self.window_size = window_size
        self.models = {}  # 每个传感器一个模型
        
    def train(self, device_id, sensor_type, data):
        """训练异常检测模型"""
        if len(data) < 10:  # 至少需要10个数据点
            return
        
        # 重塑数据以适应模型
        X = np.array(data).reshape(-1, 1)
        
        # 创建或更新模型
        model_key = f"{device_id}_{sensor_type}"
        if model_key not in self.models:
            self.models[model_key] = IsolationForest(contamination=0.1, random_state=42)
        
        # 训练模型
        self.models[model_key].fit(X)
        
    def detect(self, device_id, sensor_type, value):
        """检测异常"""
        model_key = f"{device_id}_{sensor_type}"
        
        if model_key not in self.models:
            return False, 0.0
        
        # 预测
        X = np.array([value]).reshape(1, -1)
        prediction = self.models[model_key].predict(X)
        decision_function = self.models[model_key].decision_function(X)
        
        # 转换为异常分数 (越负越异常)
        anomaly_score = -decision_function[0]
        is_anomaly = prediction[0] == -1
        
        return is_anomaly, anomaly_score

# MQTT客户端
class EdgeMQTTClient:
    def __init__(self, config, data_processor, cloud_sync):
        self.config = config
        self.data_processor = data_processor
        self.cloud_sync = cloud_sync
        self.client = mqtt.Client(client_id=config['edge_id'])
        
        # 设置回调函数
        self.client.on_connect = self.on_connect
        self.client.on_message = self.on_message
        self.client.on_disconnect = self.on_disconnect
        
        # 设置认证
        self.client.username_pw_set(config['mqtt_username'], config['mqtt_password'])
        
    def connect(self):
        """连接到MQTT代理"""
        try:
            self.client.connect(self.config['mqtt_broker'], self.config['mqtt_port'], 60)
            self.client.loop_start()
            logger.info(f"已连接到MQTT代理: {self.config['mqtt_broker']}:{self.config['mqtt_port']}")
        except Exception as e:
            logger.error(f"连接MQTT代理失败: {e}")
            raise
    
    def disconnect(self):
        """断开MQTT连接"""
        self.client.loop_stop()
        self.client.disconnect()
        logger.info("已断开MQTT连接")
    
    def on_connect(self, client, userdata, flags, rc):
        """连接成功回调"""
        if rc == 0:
            logger.info("MQTT连接成功")
            # 订阅数据主题
            client.subscribe(self.config['data_topic'])
            logger.info(f"已订阅主题: {self.config['data_topic']}")
        else:
            logger.error(f"MQTT连接失败，错误码: {rc}")
    
    def on_message(self, client, userdata, msg):
        """消息接收回调"""
        try:
            topic = msg.topic
            payload = msg.payload.decode('utf-8')
            data = json.loads(payload)
            
            logger.debug(f"收到消息 - 主题: {topic}, 数据: {data}")
            
            # 处理数据
            self.data_processor.process_data(data)
            
        except json.JSONDecodeError as e:
            logger.error(f"JSON解析错误: {e}, 数据: {msg.payload}")
        except Exception as e:
            logger.error(f"处理消息时出错: {e}")
    
    def on_disconnect(self, client, userdata, rc):
        """断开连接回调"""
        logger.warning(f"MQTT连接断开，错误码: {rc}")
        # 尝试重新连接
        try:
            time.sleep(5)
            self.client.reconnect()
        except Exception as e:
            logger.error(f"重新连接失败: {e}")
    
    def publish_control_message(self, device_id, command, payload=None):
        """发布控制消息"""
        topic = f"{self.config['control_topic']}{device_id}"
        message = {
            'command': command,
            'payload': payload,
            'timestamp': datetime.datetime.now().isoformat()
        }
        
        try:
            self.client.publish(topic, json.dumps(message))
            logger.info(f"发布控制消息 - 主题: {topic}, 消息: {message}")
        except Exception as e:
            logger.error(f"发布控制消息失败: {e}")

# 数据处理器
class DataProcessor:
    def __init__(self, config, db_session, anomaly_detector):
        self.config = config
        self.db_session = db_session
        self.anomaly_detector = anomaly_detector
        self.sensor_data_buffers = {}  # 存储传感器数据缓冲区
    
    def process_data(self, data):
        """处理传感器数据"""
        try:
            # 提取数据
            device_id = data.get('device_id')
            sensor_type = data.get('sensor_type')
            value = data.get('value')
            timestamp = data.get('timestamp')
            
            if not device_id or not sensor_type or value is None:
                logger.warning("无效的传感器数据，缺少必要字段")
                return
            
            # 转换时间戳
            if timestamp:
                try:
                    timestamp = datetime.datetime.fromisoformat(timestamp)
                except ValueError:
                    timestamp = datetime.datetime.now()
            else:
                timestamp = datetime.datetime.now()
            
            # 检测异常
            buffer_key = f"{device_id}_{sensor_type}"
            if buffer_key not in self.sensor_data_buffers:
                self.sensor_data_buffers[buffer_key] = []
            
            self.sensor_data_buffers[buffer_key].append(value)
            
            # 保持缓冲区大小
            if len(self.sensor_data_buffers[buffer_key]) > self.config['anomaly_detection_window']:
                self.sensor_data_buffers[buffer_key] = self.sensor_data_buffers[buffer_key][-self.config['anomaly_detection_window']:]
            
            # 训练异常检测模型
            self.anomaly_detector.train(device_id, sensor_type, self.sensor_data_buffers[buffer_key])
            
            # 检测异常
            is_anomaly, confidence = self.anomaly_detector.detect(device_id, sensor_type, value)
            
            # 保存数据到数据库
            sensor_data = SensorData(
                device_id=device_id,
                sensor_type=sensor_type,
                value=value,
                timestamp=timestamp,
                is_anomaly=is_anomaly
            )
            
            self.db_session.add(sensor_data)
            
            # 如果是异常，记录警报
            if is_anomaly:
                alert = AnomalyAlert(
                    device_id=device_id,
                    sensor_type=sensor_type,
                    value=value,
                    timestamp=timestamp,
                    confidence=confidence
                )
                self.db_session.add(alert)
                logger.warning(f"检测到异常 - 设备: {device_id}, 传感器: {sensor_type}, 值: {value}, 置信度: {confidence}")
            
            # 提交事务
            self.db_session.commit()
            
            logger.info(f"处理数据 - 设备: {device_id}, 传感器: {sensor_type}, 值: {value}, 是否异常: {is_anomaly}")
            
        except Exception as e:
            self.db_session.rollback()
            logger.error(f"处理数据时出错: {e}")

# 云同步服务
class CloudSyncService:
    def __init__(self, config, db_session, mqtt_client):
        self.config = config
        self.db_session = db_session
        self.mqtt_client = mqtt_client
        self.cloud_topic = "cloud/data"
    
    async def start_periodic_sync(self):
        """启动定期数据同步"""
        while True:
            try:
                logger.info("开始云同步...")
                self.sync_data_to_cloud()
                logger.info("云同步完成")
                
                # 等待下一次同步
                await asyncio.sleep(self.config['sync_interval'])
            except Exception as e:
                logger.error(f"云同步失败: {e}")
                await asyncio.sleep(self.config['sync_interval'])
    
    def sync_data_to_cloud(self):
        """将数据同步到云端"""
        try:
            # 获取未同步的数据
            unsynced_data = self.db_session.query(SensorData).filter(
                SensorData.processed == False
            ).limit(100).all()
            
            if not unsynced_data:
                logger.info("没有需要同步的数据")
                return
            
            # 准备数据发送
            data_to_send = []
            for data in unsynced_data:
                data_to_send.append({
                    'id': data.id,
                    'device_id': data.device_id,
                    'sensor_type': data.sensor_type,
                    'value': data.value,
                    'timestamp': data.timestamp.isoformat(),
                    'is_anomaly': data.is_anomaly
                })
            
            # 发送数据到云端
            payload = {
                'edge_id': self.config['edge_id'],
                'data': data_to_send,
                'timestamp': datetime.datetime.now().isoformat()
            }
            
            self.mqtt_client.publish(self.cloud_topic, json.dumps(payload))
            
            # 标记数据为已同步
            for data in unsynced_data:
                data.processed = True
            
            self.db_session.commit()
            
            logger.info(f"已同步 {len(unsynced_data)} 条数据到云端")
            
        except Exception as e:
            self.db_session.rollback()
            logger.error(f"同步数据到云端时出错: {e}")

# 主应用
async def main():
    # 初始化数据库会话
    session = Session()
    
    # 初始化异常检测器
    anomaly_detector = AnomalyDetector(window_size=CONFIG['anomaly_detection_window'])
    
    # 初始化数据处理器
    data_processor = DataProcessor(CONFIG, session, anomaly_detector)
    
    # 初始化云同步服务
    cloud_sync = CloudSyncService(CONFIG, session, None)  # MQTT客户端稍后设置
    
    # 初始化MQTT客户端
    mqtt_client = EdgeMQTTClient(CONFIG, data_processor, cloud_sync)
    mqtt_client.connect()
    
    # 设置MQTT客户端到云同步服务
    cloud_sync.mqtt_client = mqtt_client
    
    # 启动云同步任务
    sync_task = asyncio.create_task(cloud_sync.start_periodic_sync())
    
    # 保持应用运行
    try:
        await sync_task
    except KeyboardInterrupt:
        logger.info("应用被用户中断")
    finally:
        # 清理资源
        mqtt_client.disconnect()
        session.close()
        logger.info("应用已停止")

if __name__ == "__main__":
    asyncio.run(main())

难点分析

  • 边缘节点资源限制：在资源受限的设备上运行复杂算法
  • 实时数据处理：处理高频率、大量的传感器数据
  • 网络可靠性：在不稳定网络环境下保持系统正常运行
  • 安全与隐私：保护边缘设备和数据的安全
  • 云边协同机制：设计高效的云边数据同步和协同策略

扩展方向

  • 添加更多边缘智能功能（如计算机视觉、自然语言处理）
  • 实现边缘节点的自动扩展和负载均衡
  • 开发边缘设备管理平台
  • 添加预测性维护功能
  • 集成区块链技术保证数据完整性
相关推荐
TDengine （老段）21 分钟前
TDengine IDMP 应用场景：电动汽车
大数据·数据库·物联网·ai·时序数据库·iot·tdengine
大模型真好玩34 分钟前
深入浅出LangChain AI Agent智能体开发教程（十）—LangChain搭建数据分析智能助手
人工智能·python·mcp
七夜zippoe2 小时前
Python性能优化实战（三）：给内存“减负“的实用指南
python·内存·优化
WSSWWWSSW7 小时前
Seaborn数据可视化实战：Seaborn数据可视化基础-从内置数据集到外部数据集的应用
python·信息可视化·数据分析·matplotlib·seaborn
Small___ming7 小时前
Matplotlib 可视化大师系列（七）：专属篇 - 绘制误差线、等高线与更多特殊图表
python·信息可视化·matplotlib
TDengine （老段）8 小时前
TDengine IDMP 应用场景：工业锅炉监控
大数据·数据库·物联网·信息可视化·时序数据库·tdengine
荼蘼9 小时前
CUDA安装，pytorch库安装
人工智能·pytorch·python
杨荧10 小时前
基于Python的农作物病虫害防治网站 Python+Django+Vue.js
大数据·前端·vue.js·爬虫·python
骑驴看星星a10 小时前
数学建模--Topsis(Python)
开发语言·python·学习·数学建模
学习3人组10 小时前
JupyterLab在线调试实验室
python
热门推荐
01Cursor 快速入门指南：从安装到核心功能02UV安装并设置国内源03【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）04如何在Windows/Linux系统上安装adb0520个国内外主流AI绘画工具大汇总（最新免费可用~）06【踩坑笔记】50系显卡适配的 PyTorch 安装072025最新国内服务器可用docker源仓库地址大全（2025年8月更新）08KGG转MP3工具|非KGM文件|解密音频09Claude Code VSCode集成开发指南：AI编程助手完整配置10UnityHub Validation Failed下载编辑器错误，添加模块报错的解决方案