嵌入式Python工业环境监测实战：MicroPython读取多传感器数据

LCG米2025-12-13 18:40

文章目录

    • 摘要
      • 一、项目概述
        • 1.1 工业环境监测需求分析
        • 1.2 技术方案设计
      • 二、开发环境搭建
        • 2.1 硬件选型与配置
          • 2.1.1 核心控制器
          • 2.1.2 传感器模块
        • 2.2 软件环境配置
          • 2.2.1 MicroPython固件烧录
          • 2.2.2 开发工具安装
      • 三、系统架构设计
        • 3.1 硬件连接架构
        • 3.2 软件逻辑设计
      • 四、代码实现
        • 4.1 传感器驱动开发
          • 4.1.1 DHT11温湿度传感器驱动
          • 4.1.2 BH1750光照传感器驱动
          • 4.1.3 MQ-135空气质量传感器驱动
        • 4.2 数据采集模块
        • 4.3 OLED显示模块
        • 4.4 云端通信模块
      • 五、系统部署与测试
        • 5.1 硬件组装与调试
        • 5.2 功能验证测试
        • 5.3 性能优化方案
      • 六、常见问题处理
        • 6.1 传感器读数异常
        • 6.2 通信连接故障
        • 6.3 电源管理问题
      • 七、成果展示与应用
        • 7.1 数据监控界面
        • 7.2 工业场景部署案例
    • 技术图谱

摘要

本教程详细介绍基于MicroPython的工业环境监测系统开发，通过ESP32控制器集成温湿度、光照强度及空气质量传感器，实现多源数据采集、本地显示与云端传输功能，为工业物联网应用提供完整解决方案。

一、项目概述

1.1 工业环境监测需求分析

工业环境监测对生产安全、设备运行和产品质量控制具有关键作用。传统监测系统存在布线复杂、成本高昂、灵活性差等问题。基于MicroPython的嵌入式解决方案采用无线传输方式，支持多种传感器集成，能够实现实时数据采集、边缘计算和远程监控功能。

1.2 技术方案设计

系统采用模块化设计架构，以ESP32作为核心处理单元，集成三类工业常用传感器：温湿度传感器用于环境气候监测，光照传感器监测照明条件，空气质量传感器检测有害气体浓度。系统通过WiFi将数据上传至云平台，同时在本地OLED显示屏实时展示数据。
传感器层 数据采集层 数据处理层 数据输出层 DHT11温湿度传感器 BH1750光照传感器 MQ-135空气质量传感器 边缘计算 数据滤波 OLED本地显示 云平台传输 数据存储

二、开发环境搭建

2.1 硬件选型与配置
2.1.1 核心控制器

选用ESP32-WROOM-32D开发板作为核心控制器，该芯片集成双核240MHz处理器、520KB SRAM和4MB Flash，支持WiFi和蓝牙通信，具备丰富的外设接口，完全满足工业环境监测需求。

2.1.2 传感器模块
  • DHT11温湿度传感器：测量范围20-90%RH，0-50℃，精度±1℃
  • BH1750光照传感器：测量范围1-65535 lux，精度±20%
  • MQ-135空气质量传感器：检测NH3、NOx、酒精、烟雾等有害气体
2.2 软件环境配置
2.2.1 MicroPython固件烧录

首先需要将MicroPython固件烧录到ESP32开发板中：

  1. 下载最新MicroPython固件（esp32-xxx.bin）
  2. 使用esptool工具进行烧录：
bash 复制代码 
esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 esp32-xxx.bin
2.2.2 开发工具安装

推荐使用Thonny IDE进行开发，其内置MicroPython支持、文件管理和实时调试功能：

  1. 安装Thonny IDE（版本≥3.3.0）
  2. 配置解释器为MicroPython（ESP32）
  3. 设置连接端口和波特率（115200）

三、系统架构设计

3.1 硬件连接架构

显示模块 传感器阵列 ESP32控制器 OLED显示屏
I2C接口 DHT11
GPIO4 BH1750
I2C MQ-135
GPIO32 内存管理 中央处理器 存储系统 无线通信 外设接口 云服务平台

3.2 软件逻辑设计

系统采用多任务协同工作模式，主循环负责调度各个功能模块，通过定时器中断触发数据采集，采用队列机制处理传感器数据，确保系统实时性和稳定性。

四、代码实现

4.1 传感器驱动开发

创建文件：sensors.py

4.1.1 DHT11温湿度传感器驱动
python 复制代码 
import dht
import machine
import time

class DHT11Sensor:
    """
    DHT11温湿度传感器驱动类
    提供温度和湿度数据读取功能
    """
    
    def __init__(self, pin_num):
        """
        初始化DHT11传感器
        :param pin_num: GPIO引脚编号
        """
        self.pin = machine.Pin(pin_num, machine.Pin.IN, machine.Pin.PULL_UP)
        self.sensor = dht.DHT11(self.pin)
        self.last_read_time = 0
        self.read_interval = 2000  # 最小读取间隔2秒
        
    def read_data(self):
        """
        读取传感器数据
        返回: 字典包含温度、湿度值和读取状态
        """
        current_time = time.ticks_ms()
        
        # 检查读取时间间隔
        if time.ticks_diff(current_time, self.last_read_time) < self.read_interval:
            return {'temperature': None, 'humidity': None, 'status': 'waiting'}
        
        try:
            self.sensor.measure()
            temperature = self.sensor.temperature()
            humidity = self.sensor.humidity()
            
            # 数据有效性检查
            if temperature is not None and humidity is not None:
                self.last_read_time = current_time
                return {
                    'temperature': temperature,
                    'humidity': humidity,
                    'status': 'success'
                }
            else:
                return {'temperature': None, 'humidity': None, 'status': 'invalid_data'}
                
        except Exception as e:
            print(f"DHT11读取错误: {e}")
            return {'temperature': None, 'humidity': None, 'status': 'error'}
    
    def get_formatted_data(self):
        """
        获取格式化的传感器数据
        """
        data = self.read_data()
        if data['status'] == 'success':
            return f"温度: {data['temperature']}°C, 湿度: {data['humidity']}%"
        else:
            return "传感器数据读取失败"
4.1.2 BH1750光照传感器驱动
python 复制代码 
import machine

class BH1750Sensor:
    """
    BH1750光照强度传感器驱动类
    采用I2C接口通信
    """
    
    # 传感器指令定义
    POWER_DOWN = 0x00
    POWER_ON = 0x01
    RESET = 0x07
    CONT_HIGH_RES_MODE = 0x10
    CONT_HIGH_RES_MODE2 = 0x11
    CONT_LOW_RES_MODE = 0x13
    ONETIME_HIGH_RES_MODE = 0x20
    ONETIME_HIGH_RES_MODE2 = 0x21
    ONETIME_LOW_RES_MODE = 0x23
    
    def __init__(self, i2c_bus, addr=0x23):
        """
        初始化BH1750传感器
        :param i2c_bus: I2C总线对象
        :param addr: 传感器I2C地址
        """
        self.i2c = i2c_bus
        self.addr = addr
        self.power_on()
        self.set_mode(self.CONT_HIGH_RES_MODE)
        
    def power_on(self):
        """上电传感器"""
        self.i2c.writeto(self.addr, bytes([self.POWER_ON]))
        
    def power_down(self):
        """断电传感器"""
        self.i2c.writeto(self.addr, bytes([self.POWER_DOWN]))
        
    def set_mode(self, mode):
        """
        设置测量模式
        :param mode: 测量模式指令
        """
        self.mode = mode
        self.i2c.writeto(self.addr, bytes([self.mode]))
        time.sleep_ms(120)  # 模式切换需要时间
        
    def read_light_intensity(self):
        """
        读取光照强度值
        返回: 光照强度(lux)
        """
        try:
            # 发送测量指令
            self.i2c.writeto(self.addr, bytes([self.mode]))
            time.sleep_ms(180 if self.mode in [self.CONT_HIGH_RES_MODE, 
                                              self.CONT_HIGH_RES_MODE2] else 24)
            
            # 读取测量结果
            data = self.i2c.readfrom(self.addr, 2)
            intensity = (data[0] << 8 | data[1]) / 1.2
            
            return round(intensity, 2)
            
        except Exception as e:
            print(f"BH1750读取错误: {e}")
            return None
    
    def get_light_level(self, intensity):
        """
        根据光照强度判断光照等级
        :param intensity: 光照强度值
        返回: 光照等级描述
        """
        if intensity is None:
            return "未知"
        elif intensity < 10:
            return "黑暗"
        elif intensity < 50:
            return "微光"
        elif intensity < 200:
            return "弱光"
        elif intensity < 1000:
            return "正常"
        elif intensity < 10000:
            return "强光"
        else:
            return "极强光"
4.1.3 MQ-135空气质量传感器驱动
python 复制代码 
import machine
import time

class MQ135Sensor:
    """
    MQ-135空气质量传感器驱动类
    检测NH3、NOx、苯、烟雾等有害气体
    """
    
    def __init__(self, pin_num, r0=76.63):
        """
        初始化MQ-135传感器
        :param pin_num: 模拟输入引脚
        :param r0: 传感器在洁净空气中的电阻值
        """
        self.adc = machine.ADC(machine.Pin(pin_num))
        self.adc.atten(machine.ADC.ATTN_11DB)  # 设置量程为3.3V
        self.adc.width(machine.ADC.WIDTH_12BIT)  # 12位精度
        self.r0 = r0
        self.calibration_samples = 50
        self.calibrate()
        
    def read_voltage(self):
        """
        读取传感器电压值
        返回: 电压值(伏特)
        """
        raw_value = self.adc.read()
        voltage = (raw_value / 4095) * 3.3
        return round(voltage, 3)
    
    def read_resistance(self):
        """
        计算传感器电阻值
        返回: 电阻值(千欧姆)
        """
        voltage = self.read_voltage()
        # 使用分压公式计算电阻: Rs = (Vcc - Vout) * RL / Vout
        rs = (3.3 - voltage) * 10 / voltage  # RL = 10kΩ
        return round(rs, 2)
    
    def calibrate(self):
        """
        传感器自动校准
        在洁净空气中计算R0值
        """
        print("正在进行传感器校准，请确保处于洁净空气中...")
        total_rs = 0
        
        for i in range(self.calibration_samples):
            total_rs += self.read_resistance()
            time.sleep_ms(100)
            
        avg_rs = total_rs / self.calibration_samples
        self.r0 = avg_rs / 9.8  # 洁净空气中Rs/R0 ≈ 9.8
        print(f"校准完成，R0 = {round(self.r0, 2)}kΩ")
    
    def calculate_ppm(self, rs):
        """
        计算气体浓度(PPM)
        :param rs: 传感器电阻值
        返回: 气体浓度值
        """
        ratio = rs / self.r0
        # 使用近似公式计算NH3浓度
        ppm = 116.6020682 * (ratio ** -2.769034857)
        return round(ppm, 2)
    
    def get_air_quality(self, ppm):
        """
        根据PPM值判断空气质量等级
        :param ppm: 气体浓度
        返回: 空气质量描述
        """
        if ppm < 50:
            return "优"
        elif ppm < 100:
            return "良"
        elif ppm < 200:
            return "中"
        elif ppm < 300:
            return "差"
        else:
            return "严重污染"
    
    def read_air_quality(self):
        """
        读取完整的空气质量数据
        返回: 包含各项数据的字典
        """
        try:
            voltage = self.read_voltage()
            resistance = self.read_resistance()
            ppm = self.calculate_ppm(resistance)
            quality = self.get_air_quality(ppm)
            
            return {
                'voltage': voltage,
                'resistance': resistance,
                'ppm': ppm,
                'quality': quality,
                'status': 'success'
            }
            
        except Exception as e:
            print(f"MQ-135读取错误: {e}")
            return {'status': 'error'}
4.2 数据采集模块

创建文件：data_collector.py

python 复制代码 
import time
from machine import Timer
import ujson

class DataCollector:
    """
    数据采集管理器
    负责协调多个传感器数据采集和预处理
    """
    
    def __init__(self, sensors_config):
        """
        初始化数据采集器
        :param sensors_config: 传感器配置字典
        """
        self.sensors = sensors_config
        self.data_buffer = []
        self.sample_interval = 5000  # 默认采样间隔5秒
        self.max_buffer_size = 100
        self.collection_timer = None
        
    def add_sensor(self, sensor_name, sensor_obj):
        """
        添加传感器到采集列表
        :param sensor_name: 传感器名称
        :param sensor_obj: 传感器对象
        """
        self.sensors[sensor_name] = sensor_obj
        
    def set_sample_interval(self, interval_ms):
        """
        设置采样间隔
        :param interval_ms: 间隔时间(毫秒)
        """
        self.sample_interval = interval_ms
        
    def read_all_sensors(self):
        """
        读取所有传感器数据
        返回: 包含所有传感器数据的字典
        """
        sensor_data = {
            'timestamp': time.time(),
            'data': {}
        }
        
        for name, sensor in self.sensors.items():
            try:
                if hasattr(sensor, 'read_data'):
                    data = sensor.read_data()
                elif hasattr(sensor, 'read_light_intensity'):
                    intensity = sensor.read_light_intensity()
                    level = sensor.get_light_level(intensity)
                    data = {
                        'intensity': intensity,
                        'level': level
                    }
                elif hasattr(sensor, 'read_air_quality'):
                    data = sensor.read_air_quality()
                else:
                    data = {'status': 'unknown_sensor'}
                    
                sensor_data['data'][name] = data
                
            except Exception as e:
                print(f"读取传感器 {name} 时出错: {e}")
                sensor_data['data'][name] = {'status': 'error'}
        
        return sensor_data
    
    def start_continuous_collection(self):
        """
        启动定时数据采集
        """
        def collection_callback(timer):
            data = self.read_all_sensors()
            self.store_data(data)
            
            # 缓冲区管理
            if len(self.data_buffer) >= self.max_buffer_size:
                self.data_buffer.pop(0)
                
        # 创建硬件定时器
        self.collection_timer = Timer(0)
        self.collection_timer.init(
            period=self.sample_interval,
            mode=Timer.PERIODIC,
            callback=collection_callback
        )
        
        print(f"数据采集已启动，间隔: {self.sample_interval}ms")
    
    def stop_collection(self):
        """
        停止数据采集
        """
        if self.collection_timer:
            self.collection_timer.deinit()
            self.collection_timer = None
            print("数据采集已停止")
    
    def store_data(self, data):
        """
        存储采集到的数据
        :param data: 传感器数据
        """
        self.data_buffer.append(data)
        print(f"数据已存储，当前缓冲区大小: {len(self.data_buffer)}")
    
    def get_latest_data(self):
        """
        获取最新的传感器数据
        返回: 最新数据字典
        """
        if self.data_buffer:
            return self.data_buffer[-1]
        return None
    
    def get_data_summary(self):
        """
        获取数据摘要信息
        返回: 格式化后的数据摘要
        """
        latest_data = self.get_latest_data()
        if not latest_data:
            return "暂无数据"
        
        summary = f"时间: {time.localtime(latest_data['timestamp'])}\n"
        
        for sensor_name, data in latest_data['data'].items():
            if data.get('status') == 'success':
                if 'temperature' in data:
                    summary += f"{sensor_name}: {data['temperature']}°C, {data['humidity']}%\n"
                elif 'intensity' in data:
                    summary += f"{sensor_name}: {data['intensity']}lux ({data['level']})\n"
                elif 'ppm' in data:
                    summary += f"{sensor_name}: {data['ppm']}ppm ({data['quality']})\n"
            else:
                summary += f"{sensor_name}: 读取失败\n"
                
        return summary
    
    def export_data_json(self):
        """
        导出所有数据为JSON格式
        返回: JSON字符串
        """
        return ujson.dumps(self.data_buffer)
    
    def clear_buffer(self):
        """清空数据缓冲区"""
        self.data_buffer.clear()
        print("数据缓冲区已清空")
4.3 OLED显示模块

创建文件：display_manager.py

python 复制代码 
from machine import I2C, Pin
import ssd1306
import time

class DisplayManager:
    """
    OLED显示屏管理类
    负责传感器数据的可视化显示
    """
    
    def __init__(self, scl_pin, sda_pin, width=128, height=64):
        """
        初始化OLED显示屏
        :param scl_pin: I2C SCL引脚
        :param sda_pin: I2C SDA引脚
        """
        self.i2c = I2C(scl=Pin(scl_pin), sda=Pin(sda_pin))
        self.oled = ssd1306.SSD1306_I2C(width, height, self.i2c)
        self.width = width
        self.height = height
        self.current_page = 0
        self.max_pages = 3
        self.display_on = True
        
    def clear(self):
        """清空显示屏"""
        self.oled.fill(0)
        
    def show_text(self, text, x=0, y=0, clear=True):
        """
        显示文本信息
        :param text: 要显示的文本
        :param x: 起始x坐标
        :param y: 起始y坐标
        :param clear: 是否先清屏
        """
        if clear:
            self.clear()
            
        self.oled.text(text, x, y)
        self.oled.show()
    
    def show_multiline_text(self, lines, clear=True):
        """
        显示多行文本
        :param lines: 文本行列表
        :param clear: 是否先清屏
        """
        if clear:
            self.clear()
            
        for i, line in enumerate(lines):
            if i * 10 < self.height:  # 每行10像素
                self.oled.text(line, 0, i * 10)
                
        self.oled.show()
    
    def display_sensor_data(self, sensor_data):
        """
        显示传感器数据
        :param sensor_data: 传感器数据字典
        """
        if not self.display_on:
            return
            
        lines = []
        timestamp = time.localtime(sensor_data['timestamp'])
        time_str = f"{timestamp[3]:02d}:{timestamp[4]:02d}:{timestamp[5]:02d}"
        
        lines.append(f"Time: {time_str}")
        
        for sensor_name, data in sensor_data['data'].items():
            if data.get('status') == 'success':
                if 'temperature' in data:
                    lines.append(f"Temp: {data['temperature']}C Hum: {data['humidity']}%")
                elif 'intensity' in data:
                    lines.append(f"Light: {data['intensity']}lux")
                elif 'ppm' in data:
                    lines.append(f"Air: {data['ppm']}ppm ({data['quality']})")
        
        self.show_multiline_text(lines[:6])  # 最多显示6行
    
    def show_loading_animation(self, message="Loading"):
        """
        显示加载动画
        :param message: 加载提示信息
        """
        for i in range(4):
            self.clear()
            dots = "." * (i % 4)
            self.oled.text(f"{message}{dots}", 0, self.height // 2)
            self.oled.show()
            time.sleep_ms(300)
    
    def toggle_display(self):
        """切换显示屏开关状态"""
        self.display_on = not self.display_on
        if not self.display_on:
            self.clear()
            self.oled.show()
        return self.display_on
    
    def draw_progress_bar(self, x, y, width, height, progress):
        """
        绘制进度条
        :param x: 起始x坐标
        :param y: 起始y坐标
        :param width: 进度条宽度
        :param height: 进度条高度
        :param progress: 进度值(0-100)
        """
        # 绘制边框
        self.oled.rect(x, y, width, height, 1)
        
        # 计算填充宽度
        fill_width = int((progress / 100) * (width - 2))
        
        # 绘制填充部分
        if fill_width > 0:
            self.oled.fill_rect(x + 1, y + 1, fill_width, height - 2, 1)
        
        self.oled.show()
    
    def display_network_status(self, ssid, ip_addr, connected):
        """
        显示网络状态信息
        :param ssid: WiFi名称
        :param ip_addr: IP地址
        :param connected: 连接状态
        """
        self.clear()
        
        status = "Connected" if connected else "Disconnected"
        self.oled.text(f"WiFi: {status}", 0, 0)
        
        if connected:
            # 显示SSID和IP地址
            ssid_display = ssid[:16] if len(ssid) <= 16 else ssid[:13] + "..."
            self.oled.text(f"SSID: {ssid_display}", 0, 10)
            self.oled.text(f"IP: {ip_addr}", 0, 20)
        else:
            self.oled.text("Connecting...", 0, 20)
            
        self.oled.show()
4.4 云端通信模块

创建文件：cloud_connector.py

python 复制代码 
import network
import urequests
import ujson
import time

class CloudConnector:
    """
    云平台连接管理器
    负责数据上传和远程配置
    """
    
    def __init__(self, ssid, password, api_url, api_key):
        """
        初始化云连接器
        :param ssid: WiFi SSID
        :param password: WiFi密码
        :param api_url: 云平台API地址
        :param api_key: API密钥
        """
        self.ssid = ssid
        self.password = password
        self.api_url = api_url
        self.api_key = api_key
        self.wifi = network.WLAN(network.STA_IF)
        self.connected = False
        self.ip_address = None
        
    def connect_wifi(self, timeout=30):
        """
        连接WiFi网络
        :param timeout: 超时时间(秒)
        返回: 连接状态
        """
        if not self.wifi.isconnected():
            self.wifi.active(True)
            self.wifi.connect(self.ssid, self.password)
            
            start_time = time.time()
            while not self.wifi.isconnected():
                if time.time() - start_time > timeout:
                    print("WiFi连接超时")
                    return False
                time.sleep(1)
                
            self.connected = True
            self.ip_address = self.wifi.ifconfig()[0]
            print(f"WiFi连接成功, IP: {self.ip_address}")
            return True
        return True
    
    def disconnect_wifi(self):
        """断开WiFi连接"""
        self.wifi.disconnect()
        self.wifi.active(False)
        self.connected = False
        print("WiFi已断开")
    
    def upload_data(self, sensor_data):
        """
        上传传感器数据到云平台
        :param sensor_data: 传感器数据字典
        返回: 上传结果
        """
        if not self.connected:
            if not self.connect_wifi():
                return {'status': 'error', 'message': 'network_unavailable'}
        
        try:
            # 准备请求数据
            payload = {
                'device_id': 'env_monitor_001',
                'timestamp': sensor_data['timestamp'],
                'sensor_data': sensor_data['data'],
                'api_key': self.api_key
            }
            
            headers = {
                'Content-Type': 'application/json',
                'User-Agent': 'MicroPython-EnvMonitor'
            }
            
            # 发送POST请求
            response = urequests.post(
                self.api_url,
                data=ujson.dumps(payload),
                headers=headers
            )
            
            result = {
                'status': 'success' if response.status_code == 200 else 'error',
                'status_code': response.status_code,
                'response': response.text
            }
            
            response.close()
            return result
            
        except Exception as e:
            print(f"数据上传失败: {e}")
            return {'status': 'error', 'message': str(e)}
    
    def batch_upload(self, data_buffer):
        """
        批量上传数据
        :param data_buffer: 数据缓冲区
        返回: 上传统计信息
        """
        if not data_buffer:
            return {'total': 0, 'success': 0, 'failed': 0}
        
        results = []
        for data in data_buffer:
            result = self.upload_data(data)
            results.append(result)
            time.sleep(1)  # 避免请求过于频繁
            
        success_count = sum(1 for r in results if r['status'] == 'success')
        
        return {
            'total': len(results),
            'success': success_count,
            'failed': len(results) - success_count
        }
    
    def check_internet_connection(self):
        """
        检查互联网连接状态
        返回: 连接状态
        """
        try:
            response = urequests.get("http://www.google.com", timeout=5)
            response.close()
            return True
        except:
            return False
    
    def get_network_info(self):
        """
        获取网络信息
        返回: 网络信息字典
        """
        if self.connected:
            return {
                'connected': True,
                'ip_address': self.ip_address,
                'ssid': self.ssid,
                'rssi': self.wifi.status('rssi')
            }
        else:
            return {'connected': False}

五、系统部署与测试

5.1 硬件组装与调试

电源管理 3.3V电源 电源连接 GND接地 硬件准备 ESP32开发板 DHT11传感器 BH1750传感器 MQ-135传感器 OLED显示屏 GPIO4 I2C SCL-GPIO22, SDA-GPIO21 GPIO32 数据引脚连接 硬件测试 固件烧录 功能验证

5.2 功能验证测试

创建测试文件：test_system.py

python 复制代码 
from sensors import DHT11Sensor, BH1750Sensor, MQ135Sensor
from data_collector import DataCollector
from display_manager import DisplayManager
from cloud_connector import CloudConnector
from machine import I2C, Pin
import time

def test_full_system():
    """完整系统测试函数"""
    
    print("开始系统测试...")
    
    # 初始化I2C总线
    i2c = I2C(scl=Pin(22), sda=Pin(21))
    
    # 初始化传感器
    dht_sensor = DHT11Sensor(4)
    bh1750_sensor = BH1750Sensor(i2c)
    mq135_sensor = MQ135Sensor(32)
    
    # 初始化显示器
    display = DisplayManager(scl_pin=22, sda_pin=21)
    
    # 初始化数据采集器
    sensors_config = {
        'temperature': dht_sensor,
        'light': bh1750_sensor,
        'air_quality': mq135_sensor
    }
    
    collector = DataCollector(sensors_config)
    
    # 测试单个传感器
    print("测试DHT11传感器...")
    temp_data = dht_sensor.read_data()
    print(f"温湿度数据: {temp_data}")
    
    print("测试BH1750传感器...")
    light_data = bh1750_sensor.read_light_intensity()
    print(f"光照强度: {light_data}lux")
    
    print("测试MQ-135传感器...")
    air_data = mq135_sensor.read_air_quality()
    print(f"空气质量: {air_data}")
    
    # 测试数据采集
    print("测试数据采集...")
    all_data = collector.read_all_sensors()
    print(f"所有传感器数据: {all_data}")
    
    # 测试显示功能
    print("测试显示功能...")
    display.display_sensor_data(all_data)
    time.sleep(3)
    
    print("系统测试完成！")

# 运行测试
if __name__ == "__main__":
    test_full_system()
5.3 性能优化方案
  1. 电源管理优化：采用深度睡眠模式，间隔唤醒采集数据
  2. 数据压缩：对传输数据进行压缩处理，减少流量消耗
  3. 本地存储：添加SD卡模块，实现数据本地备份
  4. 异常处理：增强网络断线重连机制和数据重传功能

六、常见问题处理

6.1 传感器读数异常

问题现象 ：DHT11传感器返回None值或错误数据
解决方案：

python 复制代码 
# 添加硬件去抖动和重试机制
def robust_dht_read(sensor, max_retries=3):
    for attempt in range(max_retries):
        try:
            sensor.measure()
            temp = sensor.temperature()
            hum = sensor.humidity()
            if temp is not None and hum is not None:
                return temp, hum
        except Exception as e:
            print(f"尝试 {attempt + 1} 失败: {e}")
        time.sleep_ms(200)
    return None, None
6.2 通信连接故障

问题现象 ：WiFi连接不稳定，经常断开
解决方案：

python 复制代码 
# 增强型网络连接管理
class RobustWifiManager:
    def __init__(self, ssid, password):
        self.ssid = ssid
        self.password = password
        self.wifi = network.WLAN(network.STA_IF)
        self.retry_count = 0
        self.max_retries = 5
        
    def ensure_connection(self):
        if not self.wifi.isconnected():
            self.retry_count += 1
            if self.retry_count > self.max_retries:
                self.reboot_device()
            self.connect_wifi()
        else:
            self.retry_count = 0
            
    def connect_wifi(self):
        # 实现带日志记录的重连逻辑
        pass
6.3 电源管理问题

问题现象 ：电池供电时运行时间短
解决方案：实现动态功耗管理

python 复制代码 
class PowerManager:
    def __init__(self):
        self.sampling_interval = 5000  # 默认5秒
        self.low_power_mode = False
        
    def enter_low_power_mode(self):
        """进入低功耗模式"""
        self.low_power_mode = True
        self.sampling_interval = 30000  # 延长到30秒
        # 关闭不必要的硬件
        # 降低CPU频率
        
    def exit_low_power_mode(self):
        """退出低功耗模式"""
        self.low_power_mode = False
        self.sampling_interval = 5000
        # 恢复硬件设置

七、成果展示与应用

7.1 数据监控界面

系统提供完整的本地显示界面，实时展示环境参数：

  • 温湿度数值及历史曲线
  • 光照强度等级指示
  • 空气质量指数显示
  • 网络连接状态指示
7.2 工业场景部署案例

智能温室大棚监测：部署10个监测节点，实时监控棚内环境，通过4G网络传输数据，实现自动化通风和灌溉控制。

工厂车间环境监测：在电子制造车间部署监测系统，确保温湿度和空气质量符合生产工艺要求。

仓库存储环境监控：监测药品、食品仓库的环境条件，实现超标自动报警和日志记录。

技术图谱

MicroPython工业监测系统 硬件平台 传感器技术 通信技术 云平台 数据处理 ESP32控制器 电源管理 接口扩展 温湿度传感 光照传感 气体传感 多传感器融合 WiFi通信 蓝牙传输 4G物联网 数据存储 可视化展示 远程控制 边缘计算 数据滤波 异常检测 预测分析

本教程提供了完整的工业环境监测系统实现方案，从硬件选型到软件开发，从数据采集到云端传输，涵盖了实际应用中的所有关键技术环节。通过本方案，开发者可以快速构建稳定可靠的工业物联网监测系统。

相关推荐
自学小白菜2 小时前
每周刷题 - 第三周 - 双指针专题 - 02
python·算法·leetcode
努力的BigJiang2 小时前
Cube-slam复现及报错解决
人工智能
ComputerInBook2 小时前
代数基本概念理解——特征向量和特征值
人工智能·算法·机器学习·线性变换·特征值·特征向量
武汉唯众智创2 小时前
职业院校C语言程序设计（AIGC版）课程教学解决方案
c语言·开发语言·aigc·程序设计·c语言程序设计·c语言程序设计实训室
开发转测试3 小时前
python编码笔试题
python
漫长的~以后3 小时前
Edge TPU LiteRT V2拆解：1GB内存设备也能流畅跑AI的底层逻辑
前端·人工智能·edge
星火10243 小时前
“重生”之我用 Solo 写了一盘中国象棋
人工智能·ai编程
祝余Eleanor3 小时前
Day37 模型可视化与推理
人工智能·python·深度学习
qq_401700413 小时前
C语言void*
c语言·开发语言
热门推荐
01GitHub 镜像站点02【AutoGLM部署】本地私有化部署AI手机Agent03UV安装并设置国内源04【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）05Open-AutoGLM Windows 安装部署教程06Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Linux下V2Ray安装配置指南09BongoCat - 跨平台键盘猫动画工具10Windows 11 官方系统安装与重装完整教程（2025年最新版）