一、项目概述

本项目旨在通过软硬件结合的方式，设计并实现一个基于STM32的智慧消防监控系统。该系统主要用于实时监测环境火灾隐患，自动报警并采取初步应急措施，可广泛应用于商场、仓库、工厂、住宅等场所的消防安全管理。

技术栈关键词

• 硬件：STM32单片机、火焰传感器、烟雾传感器、温湿度传感器、红外热成像模块、蜂鸣器、继电器、OLED显示屏

• 软件：C语言、传感器数据融合算法、神经网络推理引擎（轻量化）、MQTT通信协议

• 监控流程：多传感器数据采集→数据融合分析→火灾风险判定→预警报警→联动控制→远程上报

二、系统架构设计

本系统的硬件架构以STM32单片机作为控制核心，集成多种传感器模块和执行机构，构成完整的消防监控闭环系统。

系统架构图：

┌─────────────────────────────────────────────────────────────┐
│                   智慧消防监控系统                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────┐    ┌─────────┐    ┌────────────┐              │
│  │火焰传感器│    │烟雾传感器│    │温湿度传感器│              │
│  └────┬────┘    └────┬────┘    └─────┬──────┘              │
│       │              │               │                     │
│  ┌────┴───────┬──────┴──────┬───────┴──────┐              │
│  │            │              │              │              │
│  │  多传感器数据融合处理模块   │              │              │
│  │            │              │              │              │
│  └────────────┴──────────────┴──────────────┘              │
│                    │                                        │
│                    ▼                                        │
│           ┌─────────────────┐                              │
│           │  火灾风险评估   │                              │
│           │    (AI推理)     │                              │
│           └────────┬────────┘                              │
│                    │                                        │
│        ┌───────────┴───────────┬──────────────────┐       │
│        ▼                       ▼                  ▼       │
│ ┌─────────────┐    ┌─────────────────┐  ┌──────────────┐ │
│ │声光报警模块 │    │应急控制模块     │  │数据显示模块   │ │
│ │ - 蜂鸣器    │    │ - 继电器        │  │ - OLED屏     │ │
│ │ - LED指示灯 │    │ - 水泵控制      │  │              │ │
│ └─────────────┘    │ - 通风控制      │  └──────────────┘ │
│                    └─────────────────┘                  │
│                              │                           │
│                    ┌─────────┴─────────┐                 │
│                    ▼                   ▼                 │
│            ┌─────────────┐   ┌────────────────┐          │
│            │本地存储模块 │   │无线通信模块    │          │
│            │ - SD卡      │   │ - ESP8266      │          │
│            │             │   │ - 4G模块       │          │
│            └─────────────┘   └────────┬───────┘          │
│                                        │                   │
│                                ┌───────┴───────┐         │
│                                ▼               ▼         │
│                        ┌─────────────┐ ┌─────────────┐   │
│                        │消防控制中心 │ │云服务平台   │   │
│                        │(PC端)       │ │(远程监控)   │   │
│                        └─────────────┘ └─────────────┘   │
└─────────────────────────────────────────────────────────────┘

组件选择

1. 主控芯片：STM32F407ZGT6，基于ARM Cortex-M4内核，主频168MHz，具有充足的RAM和Flash资源，支持浮点运算单元（FPU），适合运行轻量化AI算法

2. 火焰传感器：选用红外火焰传感器阵列，检测波长范围760-1100nm，灵敏度可调

3. 烟雾传感器：MQ-2气体传感器，检测范围300-10000ppm，响应时间<10s

4. 热成像模块：MLX90640红外热成像传感器，32x24像素阵列，测量范围-40°C~300°C

5. 显示模块：0.96寸OLED显示屏（128x64），I2C接口，低功耗

6. 通信模块：ESP8266 WiFi模块，支持MQTT协议，可实现远程数据传

通信协议

• I2C：用于传感器数据采集（温湿度、热成像）SPI：用于SD卡数据存储：用于WiFi模块通信CAN（可选）：用于多节点组网

三、核心代码实现

1. 多传感器数据采集模块

// sensor_data.h
#ifndef SENSOR_DATA_H
#define SENSOR_DATA_H

#include <stdint.h>
#include <stdbool.h>

// 传感器数据结构体
typedef struct {
    float temperature;      // 温度 (°C)
    float humidity;         // 湿度 (%RH)
    float smoke_level;      // 烟雾浓度
    float flame_intensity;  // 火焰强度
    float heatmap[32][24];  // 热成像数据
    uint32_t timestamp;     // 时间戳
} SensorData_t;

// 火灾风险评估等级
typedef enum {
    FIRE_SAFE = 0,      // 安全
    FIRE_WARNING = 1,   // 警告
    FIRE_DANGER = 2,    // 危险
    FIRE_ALARM = 3      // 火灾报警
} FireRiskLevel_t;

// 初始化所有传感器
bool Sensors_Init(void);

// 采集所有传感器数据
bool Sensors_CollectData(SensorData_t *data);

// 获取风险评估结果
FireRiskLevel_t GetFireRiskLevel(const SensorData_t *data);

#endif // SENSOR_DATA_H

2. 火灾检测AI模型（轻量化神经网络）

// fire_detection_nn.h
#ifndef FIRE_DETECTION_NN_H
#define FIRE_DETECTION_NN_H

#include <stdint.h>

// 神经网络输入特征
typedef struct {
    float temperature;
    float humidity;
    float smoke_concentration;
    float flame_intensity;
    float thermal_gradient;  // 热梯度
    float thermal_anomaly;   // 热异常指数
} NN_InputFeatures_t;

// 神经网络输出结果
typedef struct {
    float fire_probability;      // 火灾概率 (0-1)
    float confidence;            // 置信度
    uint8_t fire_type;           // 火灾类型: 0=无, 1=明火, 2=阴燃, 3=电气
} NN_Output_t;

// 初始化神经网络
bool NN_Init(void);

// 运行火灾检测推理
bool NN_Predict(const NN_InputFeatures_t *input, NN_Output_t *output);

// 从传感器数据提取特征
void ExtractFeatures(const SensorData_t *sensor_data, NN_InputFeatures_t *features);

#endif // FIRE_DETECTION_NN_H

3. 应急控制模块

// emergency_control.h
#ifndef EMERGENCY_CONTROL_H
#define EMERGENCY_CONTROL_H

#include <stdint.h>
#include <stdbool.h>

// 应急设备控制
typedef enum {
    DEVICE_BUZZER = 0,
    DEVICE_WARNING_LED,
    DEVICE_WATER_PUMP,
    DEVICE_VENTILATION,
    DEVICE_POWER_CUT,
    DEVICE_COUNT
} EmergencyDevice_t;

// 控制命令
typedef enum {
    CMD_TURN_ON = 0,
    CMD_TURN_OFF,
    CMD_BLINK_SLOW,
    CMD_BLINK_FAST
} ControlCommand_t;

// 初始化应急控制模块
void EmergencyControl_Init(void);

// 控制单个设备
void EmergencyControl_Device(EmergencyDevice_t device, ControlCommand_t cmd);

// 执行应急响应预案
void ExecuteEmergencyPlan(FireRiskLevel_t risk_level, uint8_t fire_type);

// 停止所有应急设备（恢复正常）
void StopAllEmergencyDevices(void);

#endif // EMERGENCY_CONTROL_H

4. 主控制系统（FreeRTOS任务）

// main.c (部分关键代码)
#include "main.h"
#include "cmsis_os.h"
#include "sensor_data.h"
#include "fire_detection_nn.h"
#include "emergency_control.h"
#include "oled_display.h"
#include "wireless_comm.h"

// FreeRTOS任务句柄
TaskHandle_t SensorTaskHandle;
TaskHandle_t AITaskHandle;
TaskHandle_t ControlTaskHandle;
TaskHandle_t DisplayTaskHandle;
TaskHandle_t CommTaskHandle;

// 共享数据队列
QueueHandle_t SensorDataQueue;
QueueHandle_t AlertQueue;

// 传感器数据采集任务
void SensorTask(void *argument) {
    SensorData_t sensor_data;
    TickType_t last_wake_time = xTaskGetTickCount();
    
    // 初始化传感器
    Sensors_Init();
    
    while (1) {
        // 采集数据
        if (Sensors_CollectData(&sensor_data)) {
            // 发送到队列
            xQueueSend(SensorDataQueue, &sensor_data, 0);
        }
        
        // 100ms周期
        vTaskDelayUntil(&last_wake_time, pdMS_TO_TICKS(100));
    }
}

// AI火灾检测任务
void AITask(void *argument) {
    SensorData_t sensor_data;
    NN_InputFeatures_t nn_features;
    NN_Output_t nn_output;
    FireAlert_t alert;
    
    // 初始化神经网络
    NN_Init();
    
    while (1) {
        // 接收传感器数据
        if (xQueueReceive(SensorDataQueue, &sensor_data, portMAX_DELAY)) {
            // 提取特征
            ExtractFeatures(&sensor_data, &nn_features);
            
            // AI推理
            if (NN_Predict(&nn_features, &nn_output)) {
                // 生成警报
                alert.timestamp = sensor_data.timestamp;
                alert.fire_probability = nn_output.fire_probability;
                alert.fire_type = nn_output.fire_type;
                alert.confidence = nn_output.confidence;
                memcpy(alert.sensor_data, sensor_data.heatmap, sizeof(sensor_data.heatmap));
                
                // 发送警报
                xQueueSend(AlertQueue, &alert, 0);
            }
        }
    }
}

// 应急控制任务
void ControlTask(void *argument) {
    FireAlert_t alert;
    FireRiskLevel_t risk_level;
    
    // 初始化控制模块
    EmergencyControl_Init();
    
    while (1) {
        if (xQueueReceive(AlertQueue, &alert, portMAX_DELAY)) {
            // 根据AI输出确定风险等级
            if (alert.fire_probability > 0.8f && alert.confidence > 0.7f) {
                risk_level = FIRE_ALARM;
            } else if (alert.fire_probability > 0.5f && alert.confidence > 0.5f) {
                risk_level = FIRE_DANGER;
            } else if (alert.fire_probability > 0.2f) {
                risk_level = FIRE_WARNING;
            } else {
                risk_level = FIRE_SAFE;
            }
            
            // 执行应急预案
            ExecuteEmergencyPlan(risk_level, alert.fire_type);
        }
    }
}

// 显示任务
void DisplayTask(void *argument) {
    FireAlert_t alert;
    char display_buffer[128];
    
    OLED_Init();
    
    while (1) {
        if (xQueuePeek(AlertQueue, &alert, 0)) {
            // 显示火灾信息
            snprintf(display_buffer, sizeof(display_buffer), 
                    "Fire Prob: %.1f%%\nType: %d\nConf: %.1f%%",
                    alert.fire_probability * 100,
                    alert.fire_type,
                    alert.confidence * 100);
            
            OLED_Clear();
            OLED_ShowString(0, 0, display_buffer);
            OLED_ShowString(0, 32, "Status: ALERT");
        } else {
            // 显示正常状态
            OLED_Clear();
            OLED_ShowString(0, 0, "Fire Detection");
            OLED_ShowString(0, 16, "System Active");
            OLED_ShowString(0, 32, "Status: NORMAL");
        }
        
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

// 无线通信任务
void CommTask(void *argument) {
    FireAlert_t alert;
    
    // 初始化无线通信
    WiFi_Init();
    MQTT_Init();
    
    while (1) {
        if (xQueuePeek(AlertQueue, &alert, 0)) {
            // 发送警报到云平台
            MQTT_SendAlert(&alert);
        }
        
        // 发送心跳包
        MQTT_SendHeartbeat();
        
        vTaskDelay(pdMS_TO_TICKS(10000));  // 10秒间隔
    }
}

int main(void) {
    // HAL库初始化
    HAL_Init();
    SystemClock_Config();
    
    // FreeRTOS初始化
    osKernelInitialize();
    
    // 创建队列
    SensorDataQueue = xQueueCreate(10, sizeof(SensorData_t));
    AlertQueue = xQueueCreate(5, sizeof(FireAlert_t));
    
    // 创建任务
    xTaskCreate(SensorTask, "SensorTask", 512, NULL, 3, &SensorTaskHandle);
    xTaskCreate(AITask, "AITask", 1024, NULL, 4, &AITaskHandle);
    xTaskCreate(ControlTask, "ControlTask", 512, NULL, 5, &ControlTaskHandle);
    xTaskCreate(DisplayTask, "DisplayTask", 512, NULL, 2, &DisplayTaskHandle);
    xTaskCreate(CommTask, "CommTask", 1024, NULL, 1, &CommTaskHandle);
    
    // 启动调度器
    osKernelStart();
    
    while (1) {
        // 空闲任务
    }
}

5. 无线通信模块（MQTT协议）

// wireless_comm.c (部分代码)
#include "wireless_comm.h"
#include "esp8266.h"
#include <cJSON.h>
#include <string.h>

// MQTT连接状态
static bool mqtt_connected = false;

// 初始化WiFi和MQTT
bool WiFi_Init(void) {
    // 初始化ESP8266
    ESP8266_Init();
    
    // 连接WiFi
    if (ESP8266_ConnectAP("Your_SSID", "Your_Password") != ESP8266_OK) {
        return false;
    }
    
    return true;
}

bool MQTT_Init(void) {
    // 连接MQTT服务器
    if (ESP8266_MQTTConnect("mqtt.broker.com", 1883, "fire_detection_client") != ESP8266_OK) {
        return false;
    }
    
    mqtt_connected = true;
    
    // 订阅控制主题
    ESP8266_MQTTSubscribe("fire_system/control");
    
    return true;
}

// 发送警报信息
void MQTT_SendAlert(const FireAlert_t *alert) {
    if (!mqtt_connected || alert == NULL) return;
    
    cJSON *root = cJSON_CreateObject();
    
    // 构建JSON消息
    cJSON_AddNumberToObject(root, "timestamp", alert->timestamp);
    cJSON_AddNumberToObject(root, "fire_probability", alert->fire_probability);
    cJSON_AddNumberToObject(root, "fire_type", alert->fire_type);
    cJSON_AddNumberToObject(root, "confidence", alert->confidence);
    
    // 添加热成像数据（简化版）
    cJSON *heatmap = cJSON_CreateArray();
    for (int i = 0; i < 8; i++) {  // 只发送部分数据以减少带宽
        cJSON *row = cJSON_CreateArray();
        for (int j = 0; j < 6; j++) {
            cJSON_AddItemToArray(row, cJSON_CreateNumber(alert->sensor_data[i*4][j*4]));
        }
        cJSON_AddItemToArray(heatmap, row);
    }
    cJSON_AddItemToObject(root, "heatmap", heatmap);
    
    // 转换为字符串并发送
    char *json_str = cJSON_Print(root);
    ESP8266_MQTTPublish("fire_system/alerts", json_str, strlen(json_str), 1);
    
    // 清理
    cJSON_Delete(root);
    free(json_str);
}

// 发送心跳包
void MQTT_SendHeartbeat(void) {
    if (!mqtt_connected) return;
    
    cJSON *root = cJSON_CreateObject();
    cJSON_AddStringToObject(root, "device_id", "FIRE_DETECTOR_001");
    cJSON_AddNumberToObject(root, "uptime", HAL_GetTick() / 1000);
    cJSON_AddStringToObject(root, "status", "online");
    
    char *json_str = cJSON_Print(root);
    ESP8266_MQTTPublish("fire_system/heartbeat", json_str, strlen(json_str), 0);
    
    cJSON_Delete(root);
    free(json_str);
}

四、项目总结与扩展

本项目成功设计并实现了一个基于STM32的智慧消防监控系统，具有以下特点：

1. 多传感器融合：整合火焰、烟雾、温湿度、热成像等多种传感器，提高检测准确性

2. 智能火灾识别：采用轻量化神经网络进行火灾风险评估，降低误报率

3. 快速应急响应：毫秒级响应时间，自动执行应急预案

4. 远程监控能力：支持MQTT协议，实现云平台远程监控

5. 模块化设计：便于功能扩展和维护

技术创新点

1. 嵌入式AI推理：在STM32上部署轻量化神经网络，实现本地智能分析

2. 多传感器数据融合：结合传统阈值法和AI算法，提高系统可靠性

3. 实时操作系统：采用FreeRTOS实现多任务并发处理

4. 热成像分析：通过红外热成像检测隐藏火源和温度异常

未来发展

本项目提供了一个完整的智慧消防系统框架，可根据具体需求进行调整和扩展，具有良好的实用价值和教学意义。

1. 增加更多传感器：CO传感器、可燃气体传感器等

2. 优化AI模型：使用更复杂的网络结构，提高识别精度

3. 增加定位功能：结合UWB或蓝牙定位，精确定位火源位置

4. 多节点组网：构建分布式消防监控网络

5. 太阳能供电：实现偏远地区无源部署

6. 增加视频监控：结合摄像头进行视觉验证