Conception d'un dispositif de détection et d'alarme de fuite de gaz basé sur un micro-ordinateur monopuce

1. Présentation du projet

Les fuites de gaz sont une situation courante et dangereuse qui peut entraîner des incendies, des explosions et des blessures, voire la mort. Afin de détecter les fuites de gaz à temps et de prendre les mesures de sécurité correspondantes, un dispositif de détection et d'alarme de fuite de gaz basé sur un micro-ordinateur monopuce est conçu.

La puce de contrôle principale utilise STM32F103C8T6 comme puce de contrôle principale, qui possède de puissantes capacités de calcul et de contrôle. Le MQ-5 a été choisi comme capteur de détection de gaz, capable de détecter la concentration de gaz dans l'environnement et de la convertir en signal électrique pour la sortie. L'appareil surveille la concentration de gaz en temps réel en lisant le signal analogique émis par le capteur et en obtenant la valeur numérique correspondante via la conversion ADC.

Lorsqu'il est détecté que la concentration de gaz dépasse le seuil de sécurité défini, l'appareil déclenche le mécanisme d'alarme. En contrôlant le buzzer, une alarme haute fréquence retentit pour attirer l'attention et vous rappeler les situations dangereuses. Dans le même temps, l'appareil contrôlera le clignotement de la lumière LED pour un rappel visuel à l'utilisateur. De telles méthodes d'alarme multiples peuvent efficacement alerter les personnes dans différents environnements.

Afin d'améliorer encore la rapidité et la fiabilité des alarmes, le module SIM800C est également intégré pour envoyer des messages texte d'alarme aux contacts désignés. Lorsque la concentration de gaz dépasse la norme, l'appareil envoie un message texte d'alarme prédéfini via le module SIM800C pour avertir le personnel concerné de prendre des mesures en temps opportun.

Grâce à la conception ci-dessus, le dispositif de détection et d'alarme de fuite de gaz basé sur le micro-ordinateur monopuce peut surveiller la concentration de gaz dans l'environnement en temps réel et alerter l'utilisateur au moyen d'alarmes sonores et visuelles et de notifications SMS lorsque des conditions anormales sont détectées. De tels dispositifs peuvent être largement utilisés dans les environnements domestiques, industriels et commerciaux pour assurer une protection efficace de la sécurité des personnes et des biens.

2. Sélection du matériel

Dans cette conception, le matériel suivant est sélectionné pour mettre en œuvre le dispositif d'alarme de détection de fuite de gaz.

【1】Puce de contrôle principale : STM32F103C8T6. La puce est un microcontrôleur puissant à faible consommation doté de périphériques riches et de bonnes performances. Il intègre plusieurs broches d'entrée et de sortie à usage général, un convertisseur analogique-numérique (ADC), une minuterie et des fonctions d'interface série, ce qui le rend adapté à diverses applications embarquées.

【2】Capteur de détection de gaz : MQ-5. Le MQ-5 est un capteur de gaz courant capable de détecter des gaz inflammables tels que le gaz de pétrole liquéfié (GPL), le gaz naturel et le méthane. Il est basé sur des matériaux semi-conducteurs sensibles aux gaz et lorsqu'il détecte que la concentration du gaz cible dépasse un seuil défini, sa valeur de résistance change. En mesurant le changement de valeur de résistance, il est possible de déterminer si la concentration de gaz dépasse la norme.

【3】Buzzer : utilisé pour émettre des sons d'alarme pour rappeler aux gens de faire attention. Lors du choix d'un buzzer approprié, vous devez prendre en compte des facteurs tels que son volume, sa tension de fonctionnement et sa méthode de pilotage.

【4】 Lumière LED : utilisée pour rappeler aux gens de faire attention et indiquer l'état de l'alarme. Choisir la bonne LED nécessite de prendre en compte des facteurs tels que sa luminosité, sa tension de fonctionnement et sa couleur.

【5】Module SIM800C : utilisé pour envoyer des messages texte d'alarme. SIM800C est un module qui prend en charge la communication GSM/GPRS et peut communiquer avec la puce de contrôle principale via les commandes AT. Il a une petite taille, une faible consommation d'énergie et des performances stables, et convient aux besoins de communication SMS dans les applications IoT.

3. Idées de conception de système

Idées de conception de logiciels :

【1】Initialisation : initialisez le microcontrôleur STM32F103C8T6 et les périphériques, y compris la configuration des broches, les paramètres d'horloge, etc.

【2】Détection de gaz : utilisez le module ADC pour lire le signal analogique du capteur MQ-5 et le convertir en valeur numérique correspondante.

【3】 Jugement de la concentration de gaz : selon la courbe caractéristique du capteur, la valeur numérique lue est convertie en concentration réelle de gaz.

【4】 Jugement d'alarme : jugez si la concentration de gaz dépasse le seuil de sécurité défini.

【5】Traitement des alarmes :

• Contrôlez le buzzer pour déclencher une alarme.
• Lumière LED de contrôle clignotante.
• Utilisez le module SIM800C pour envoyer des messages texte d'alarme aux contacts désignés.

【6】Boucle principale : la détection de gaz et l'évaluation des alarmes sont effectuées en continu dans la boucle principale pour maintenir les fonctions de surveillance et d'alarme en temps réel du système.

Exemple de pseudocode :

初始化：
    初始化STM32F103C8T6单片机和外设设置
    
主循环：
    while (true) {
        煤气检测();
        煤气浓度判断();
        报警判断();
        延时一段时间;
    }

煤气检测：
    读取MQ-5传感器的模拟信号;
    将模拟信号转换为数字值;

煤气浓度判断：
    根据传感器的特性曲线，将数字值转换为实际的煤气浓度;

报警判断：
    if (煤气浓度超过安全阈值) {
        报警处理();
    }

报警处理：
    控制蜂鸣器发出报警声;
    控制LED灯光闪烁;
    使用SIM800C模块发送报警短信给指定的联系人;

4. Mise en œuvre du code

4.1 Programme principal

#include "stm32f10x.h"

// 定义蜂鸣器控制引脚和LED控制引脚
#define BUZZER_PIN      GPIO_Pin_0
#define BUZZER_PORT     GPIOA

#define LED_PIN         GPIO_Pin_1
#define LED_PORT        GPIOA

// 定义煤气传感器控制引脚
#define GAS_SENSOR_PIN  GPIO_Pin_2
#define GAS_SENSOR_PORT GPIOA

// 定义SIM800C模块的发送引脚
#define SIM800C_SEND_PIN    GPIO_Pin_3
#define SIM800C_SEND_PORT   GPIOA

// 定义报警阈值
#define THRESHOLD           1000

// 声明函数原型
void GPIO_Init(void);
void ADC_Init(void);
void Buzzer_Alarm(void);
void LED_Flash(void);
void Send_SMS(void);

int main(void)
{
    
    
    // 初始化GPIO和ADC
    GPIO_Init();
    ADC_Init();

    while (1)
    {
    
    
        // 进行煤气浓度检测
        u16 gasValue = ADC_GetConversionValue(ADC1);

        // 如果煤气浓度超过阈值，则触发报警
        if (gasValue > THRESHOLD)
        {
    
    
            Buzzer_Alarm();
            LED_Flash();
            Send_SMS();
        }
    }
}

// GPIO初始化函数
void GPIO_Init(void)
{
    
    
    // 打开GPIO时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef gpioInitStruct;

    // 配置蜂鸣器引脚为推挽输出
    gpioInitStruct.GPIO_Pin = BUZZER_PIN;
    gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(BUZZER_PORT, &gpioInitStruct);

    // 配置LED引脚为推挽输出
    gpioInitStruct.GPIO_Pin = LED_PIN;
    gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(LED_PORT, &gpioInitStruct);

    // 配置煤气传感器引脚为模拟输入
    gpioInitStruct.GPIO_Pin = GAS_SENSOR_PIN;
    gpioInitStruct.GPIO_Mode = GPIO_Mode_AIN;
    gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GAS_SENSOR_PORT, &gpioInitStruct);

    // 配置SIM800C模块的发送引脚为推挽输出
    gpioInitStruct.GPIO_Pin = SIM800C_SEND_PIN;
    gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(SIM800C_SEND_PORT, &gpioInitStruct);
}

// ADC初始化函数
void ADC_Init(void)
{
    
    
    // 打开ADC时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);

    ADC_InitTypeDef adcInitStruct;

    // ADC配置
    adcInitStruct.ADC_Mode = ADC_Mode_Independent;
    adcInitStruct.ADC_ScanConvMode = DISABLE;
    adcInitStruct.ADC_ContinuousConvMode = ENABLE;
    adcInitStruct.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    adcInitStruct.ADC_DataAlign = ADC_DataAlign_Right;
    adcInitStruct.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &adcInitStruct);

    // 配置ADC通道
    ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 1, ADC_SampleTime_55Cycles5);

    // 打开ADC
    ADC_Cmd(ADC1, ENABLE);

    // 开始ADC转换
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
}

// 触发蜂鸣器报警
void Buzzer_Alarm(void)
{
    
    
    GPIO_SetBits(BUZZER_PORT, BUZZER_PIN);   // 打开蜂鸣器
    Delay(1000);                            // 延时一段时间
    GPIO_ResetBits(BUZZER_PORT, BUZZER_PIN); // 关闭蜂鸣器
}

// LED闪烁提醒
void LED_Flash(void)
{
    
    
    for (int i = 0; i < 10; i++)
    {
    
    
        GPIO_SetBits(LED_PORT, LED_PIN);     // 打开LED
        Delay(500);                          // 延时一段时间
        GPIO_ResetBits(LED_PORT, LED_PIN);   // 关闭LED
        Delay(500);                          // 延时一段时间
    }
}

// 发送报警短信
void Send_SMS(void)
{
    
    
    // 这里编写与SIM800C模块通信的代码，发送报警短信
}

4.2 Code SIM800C

#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>

// 定义SIM800C模块的串口引脚
#define SIM800C_USART           USART2
#define SIM800C_USART_GPIO      GPIOA
#define SIM800C_USART_TX_PIN    GPIO_Pin_2
#define SIM800C_USART_RX_PIN    GPIO_Pin_3

// 定义发送缓冲区和接收缓冲区的大小
#define TX_BUFFER_SIZE  128
#define RX_BUFFER_SIZE  128

// 声明全局变量
char tx_buffer[TX_BUFFER_SIZE]; // 发送缓冲区
char rx_buffer[RX_BUFFER_SIZE]; // 接收缓冲区
uint8_t rx_index = 0;           // 接收缓冲区索引

// 函数原型
void USART2_Init(void);
void USART2_SendString(const char* string);
void USART2_IRQHandler(void);
void Send_AT_Command(const char* at_command);
void Send_SMS(void);

int main(void)
{
    
    
    USART2_Init();
    
    while (1)
    {
    
    
        // 在主循环中调用Send_SMS函数即可触发发送短信
    }
}

// 初始化USART2
void USART2_Init(void)
{
    
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);    // 打开GPIOA和AFIO时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);                          // 打开USART2时钟

    GPIO_InitTypeDef gpioInitStruct;
    USART_InitTypeDef usartInitStruct;
    NVIC_InitTypeDef nvicInitStruct;

    // 配置USART2的GPIO引脚
    gpioInitStruct.GPIO_Pin = SIM800C_USART_TX_PIN;
    gpioInitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(SIM800C_USART_GPIO, &gpioInitStruct);

    gpioInitStruct.GPIO_Pin = SIM800C_USART_RX_PIN;
    gpioInitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(SIM800C_USART_GPIO, &gpioInitStruct);

    // 配置USART2
    usartInitStruct.USART_BaudRate = 115200;
    usartInitStruct.USART_WordLength = USART_WordLength_8b;
    usartInitStruct.USART_StopBits = USART_StopBits_1;
    usartInitStruct.USART_Parity = USART_Parity_No;
    usartInitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    usartInitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
    USART_Init(SIM800C_USART, &usartInitStruct);

    // 配置USART2中断
    nvicInitStruct.NVIC_IRQChannel = USART2_IRQn;
    nvicInitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    nvicInitStruct.NVIC_IRQChannelSubPriority = 0;
    nvicInitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&nvicInitStruct);

    // 启动USART2接收中断
    USART_ITConfig(SIM800C_USART, USART_IT_RXNE, ENABLE);

    // 启动USART2
    USART_Cmd(SIM800C_USART, ENABLE);
}

// 发送字符串到USART2
void USART2_SendString(const char* string)
{
    
    
    uint16_t length = strlen(string);
    for (uint16_t i = 0; i < length; i++)
    {
    
    
        USART_SendData(SIM800C_USART, string[i]);
        while (USART_GetFlagStatus(SIM800C_USART, USART_FLAG_TXE) == RESET);
    }
}

// USART2中断处理函数
void USART2_IRQHandler(void)
{
    
    
    if (USART_GetITStatus(SIM800C_USART, USART_IT_RXNE) != RESET)
    {
    
    
        char receivedData = USART_ReceiveData(SIM800C_USART);
        rx_buffer[rx_index++] = receivedData;

        // 处理接收到的数据
        // ...

        USART_ClearITPendingBit(SIM800C_USART, USART_IT_RXNE);
    }
}

// 发送AT指令
void Send_AT_Command(const char* at_command)
{
    
    
    memset(rx_buffer, 0, RX_BUFFER_SIZE); // 清空接收缓冲区
    rx_index = 0;

    USART2_SendString(at_command);

    // 等待模块返回数据
    while (strncmp(rx_buffer, "OK", 2) != 0 && strncmp(rx_buffer, "ERROR", 5) != 0)
    {
    
    
        // 延时一段时间
        Delay(10);
    }

    // 处理模块返回的数据
    // ...
}

// 发送短信
void Send_SMS(void)
{
    
    
    // 发送AT指令设置短信模式
    Send_AT_Command("AT+CMGF=1\r\n");

    // 发送AT指令设置短信收件人和内容
    Send_AT_Command("AT+CMGS=\"+861**********\"\r\n");
    Send_AT_Command("Hello, this is a test message.\r\n");

    // 发送短信结束标志（Ctrl+Z）
    USART2_SendString("\x1A");
}

5. Résumé

Ce projet conçoit un dispositif de détection et d'alarme de fuite de gaz basé sur un micro-ordinateur monopuce. En utilisant STM32F103C8T6 comme puce de contrôle principale et un capteur de gaz MQ-5 pour la détection de gaz, il peut rappeler efficacement aux utilisateurs le danger de fuite de gaz. En contrôlant le mécanisme d'alarme du buzzer et de la lumière LED, et en utilisant le module SIM800C pour envoyer des messages texte d'alarme, les utilisateurs peuvent prendre des mesures en temps opportun pour éviter les dangers potentiels. Ce projet combine les connaissances en matière de conception matérielle et de développement de logiciels embarqués pour fournir aux utilisateurs une solution fiable de détection et d'alarme de fuite de gaz.