Conception d'un système de contrôle de la température d'une serre à fleurs basé sur STM32

Introduction

Alors que la demande de culture de fleurs continue de croître, la construction et la gestion de serres de fleurs sont devenues un sujet important. Dans les serres fleuries, la température est un paramètre environnemental crucial qui a un impact direct sur la croissance et le développement des fleurs. Afin de fournir un environnement de croissance stable, il devient très important de contrôler la température de la serre.

Ce projet conçoit un système de contrôle de la température d'une serre à fleurs basé sur le microcontrôleur STM32. Le système utilise STM32F103C8T6 comme puce de contrôle principale pour surveiller et contrôler la température dans la serre grâce à une connexion avec des modules matériels tels que le capteur de température DS18B20 et un écran OLED de 0,96 pouce. Parallèlement, le système est également équipé de deux boutons indépendants pour régler le seuil de température.

Le capteur de température utilise DS18B20, qui peut surveiller avec précision la température dans la serre. Les données de température peuvent être obtenues en temps réel grâce à la communication avec le microcontrôleur STM32. L'écran utilise un écran OLED de 0,96 pouces avec protocole SPI, qui est utilisé pour afficher la température de l'environnement actuel et le seuil de température. Les utilisateurs peuvent définir le seuil de température via des boutons afin que le système puisse contrôler la température en fonction du seuil défini.

Lorsque la température est inférieure au seuil de température défini, le système contrôlera le ventilateur d'air chaud via le relais pour chauffer et souffler de l'air chaud afin de contrôler la température ambiante. En surveillant la température en temps réel et en la contrôlant en fonction du seuil défini, le système peut maintenir la température dans la serre dans une plage appropriée et fournir un environnement de croissance stable aux fleurs.

Le projet est conçu pour accroître l'automatisation des serres de fleurs et réduire le fardeau de la gestion manuelle, tout en fournissant une solution stable de contrôle de la température pour favoriser la croissance et le développement des fleurs. En utilisant des microcontrôleurs STM32 et des modules matériels associés, le système peut réaliser une surveillance en temps réel et un contrôle automatique de la température, offrant ainsi une solution pratique et efficace pour les gestionnaires de serres de fleurs.

Le schéma final du modèle de système après avoir ajouté la télécommande :

2. Introduction à la sélection du matériel

Voici la sélection matérielle du système de contrôle de la température de la serre à fleurs basée sur STM32 :

【1】Puce de contrôle principale : STM32F103C8T6

• La série STM32F103 offre de bonnes performances et des périphériques riches, ce qui la rend adaptée aux applications embarquées.
• STM32F103C8T6 est un microcontrôleur ARM Cortex-M3 32 bits avec 64 Ko de mémoire Flash et 20 Ko de RAM.

【2】Capteur de température : DS18B20

• DS18B20 est un capteur de température numérique qui utilise une seule interface de bus pour la communication.
• Il présente les caractéristiques de haute précision, étanche à l'eau et à la poussière, et est très approprié pour mesurer la température dans la serre.
• Connectez-vous au port GPIO du STM32 via des broches et utilisez le protocole OneWire pour la communication de données.

【3】Affichage : écran OLED de 0,96 pouces

• Choisissez un écran OLED de 0,96 pouces prenant en charge le protocole SPI comme dispositif d'affichage, qui peut facilement afficher la température ambiante et le seuil de température.
• Les écrans OLED présentent les avantages d’une faible consommation d’énergie, d’un contraste élevé et de angles de vision larges, ce qui les rend adaptés aux applications embarquées.

【4】Boutons : deux boutons indépendants

• Sélectionnez deux boutons indépendants pour régler le seuil de température, qui peut être augmenté ou diminué en appuyant sur le bouton.

【5】Relais : utilisé pour contrôler le chauffage du ventilateur à air chaud.

• Selon le seuil de température et les données de température en temps réel, l'interrupteur du relais est contrôlé via le port GPIO du STM32 pour contrôler le chauffage du ventilateur à air chaud.
• La sélection du relais doit être déterminée en fonction du courant et de la tension nominaux du ventilateur à air chaud pour garantir un fonctionnement normal.

3. Idées de conception

Idées de conception de logique logicielle :

【1】Initialisez les périphériques STM32, notamment GPIO, SPI, USART, etc.

【2】Réglez la valeur initiale du seuil de température et ajustez le seuil via les boutons.

【3】 Boucle pour lire les données du capteur de température DS18B20 et comparer la valeur de température lue avec la valeur seuil.

【4】Si la température actuelle est inférieure au seuil, le relais de commande est fermé et le ventilateur d'air chaud commence à chauffer ; sinon, le relais est ouvert pour arrêter le chauffage.

【5】Affichez la valeur de température et la valeur seuil sur l'écran OLED et envoyez-les à l'utilisateur via le port série USART.

【6】 Exécutez en continu les étapes ci-dessus dans un cycle pour réaliser la fonction de contrôle automatique de la température de la serre.

pseudo-code :

// 定义变量
float temperature;  // 当前温度值
float threshold;    // 温度阀值

// 初始化硬件和外设
void initialize() {
    
    
    initialize_GPIO();     // 初始化GPIO
    initialize_SPI();      // 初始化SPI
    initialize_USART();    // 初始化USART
    initialize_DS18B20();  // 初始化DS18B20
    initialize_OLED();     // 初始化OLED显示屏
    initialize_Button();   // 初始化按键
    initialize_Relay();    // 初始化继电器
}

// 读取温度值
float readTemperature() {
    
    
    // 通过DS18B20读取温度值
    // 返回温度值
}

// 读取阀值
float readThreshold() {
    
    
    // 读取按键的状态，并调节阀值
    // 返回阀值
}

// 控制加热器
void controlHeater(float currTemperature, float currThreshold) {
    
    
    if (currTemperature < currThreshold) {
    
    
        // 温度低于阀值，控制继电器闭合，热风机加热
    } else {
    
    
        // 温度高于或等于阀值，打开继电器，停止加热
    }
}

// 显示温度和阀值
void displayTemperature(float currTemperature, float currThreshold) {
    
    
    // 在OLED屏幕上显示温度值和阀值
    // 通过USART串口输出温度值和阀值
}

// 主函数
int main() {
    
    
    initialize();  // 初始化
    
    while (1) {
    
    
        temperature = readTemperature();          // 读取温度值
        threshold = readThreshold();              // 读取阀值
        controlHeater(temperature, threshold);     // 控制加热器
        displayTemperature(temperature, threshold);// 显示温度和阀值
    }

    return 0;
}

Ce qui précède sont les idées de base de conception de logique logicielle et le pseudo-code.

4. Mise en œuvre du code

4.1 Lire l'affichage de la température

Voici le code d'implémentation permettant d'utiliser STM32F103C8T6 pour lire les données du capteur de température DS18B20 et afficher la température sur l'écran OLED :

#include "stm32f10x.h"
#include "delay.h"
#include "onewire.h"
#include "ds18b20.h"
#include "ssd1306.h"

int main(void)
{
    
    
    // 初始化延迟函数
    delay_init();
    
    // 初始化OLED显示屏
    SSD1306_Init();
    
    // 初始化DS18B20温度传感器
    DS18B20_Init();
    
    float temperature = 0.0;
    char tempStr[10];
    
    while (1)
    {
    
    
        // 读取DS18B20温度传感器数据
        temperature = DS18B20_GetTemp();
        
        // 将温度转换为字符串
        sprintf(tempStr, "%.2f C", temperature);
        
        // 清空OLED显示屏
        SSD1306_Clear();
        
        // 在OLED显示屏上显示温度
        SSD1306_GotoXY(0, 0);
        SSD1306_Puts("Temperature:", &Font_7x10, SSD1306_COLOR_WHITE);
        SSD1306_GotoXY(0, 20);
        SSD1306_Puts(tempStr, &Font_11x18, SSD1306_COLOR_WHITE);
        
        // 刷新OLED显示屏
        SSD1306_UpdateScreen();
        
        // 延时一段时间
        delay_ms(1000);
    }
}

Dans le code, des fichiers de bibliothèque packagés sont utilisés, notamment des fichiers de bibliothèque pour la fonction de retard (delay.h), le bus OneWire (onewire.h), le capteur de température DS18B20 (ds18b20.h) et l'écran OLED SSD1306 (ssd1306.h).

Dans la fonction principale, initialisez la fonction de retard et l'affichage OLED, et initialisez le capteur de température DS18B20. Entrez ensuite dans une boucle infinie, lisez les données de température du capteur de température DS18B20 dans la boucle et affichez la température sur l'écran OLED. Les données de température sont converties en chaîne via la fonction sprintf et affichées sur l'écran OLED à l'aide de la fonction de bibliothèque SSD1306. Retardez pendant un certain temps grâce à la fonction de retard pour obtenir des mises à jour régulières de la température.

4.2 Code DS18B20

Code du fichier d'en-tête :

#ifndef DS18B20_H
#define DS18B20_H

#include "stm32f10x.h"

// DS18B20引脚定义
#define DS18B20_GPIO_PORT   GPIOA
#define DS18B20_GPIO_PIN    GPIO_Pin_0

// DS18B20函数声明
void DS18B20_Init(void);
void DS18B20_WriteByte(uint8_t data);
uint8_t DS18B20_ReadByte(void);
float DS18B20_GetTemp(void);

#endif

Code du fichier source :

#include "ds18b20.h"
#include "delay.h"

// 初始化DS18B20温度传感器
void DS18B20_Init(void)
{
    
    
    GPIO_InitTypeDef GPIO_InitStructure;
    
    // 使能GPIOA时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
    // 配置GPIOA引脚为推挽输出
    GPIO_InitStructure.GPIO_Pin = DS18B20_GPIO_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(DS18B20_GPIO_PORT, &GPIO_InitStructure);
    
    // 将引脚拉低一段时间
    GPIO_ResetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
    delay_us(500);
    
    // 将引脚拉高一段时间
    GPIO_SetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
    delay_us(80);
    
    // 等待DS18B20的响应
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(DS18B20_GPIO_PORT, &GPIO_InitStructure);
    delay_us(80);
}

// 向DS18B20写入一个字节的数据
void DS18B20_WriteByte(uint8_t data)
{
    
    
    uint8_t i;
    
    // 将引脚设置为推挽输出
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = DS18B20_GPIO_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(DS18B20_GPIO_PORT, &GPIO_InitStructure);
    
    // 写入数据
    for (i = 0; i < 8; i++)
    {
    
    
        GPIO_ResetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
        delay_us(2);
        if (data & 0x01)
        {
    
    
            GPIO_SetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
        }
        delay_us(60);
        GPIO_SetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
        delay_us(2);
        data >>= 1;
    }
}

// 从DS18B20读取一个字节的数据
uint8_t DS18B20_ReadByte(void)
{
    
    
    uint8_t i, data = 0;
    
    // 将引脚设置为推挽输出
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = DS18B20_GPIO_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(DS18B20_GPIO_PORT, &GPIO_InitStructure);
    
    // 读取数据
    for (i = 0; i < 8; i++)
    {
    
    
        GPIO_ResetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
        delay_us(2);
        GPIO_SetBits(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN);
        delay_us(2);
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
        GPIO_Init(DS18B20_GPIO_PORT, &GPIO_InitStructure);
        delay_us(2);
        data >>= 1;
        if (GPIO_ReadInputDataBit(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN))
        {
    
    
            data |= 0x80;
        }
        delay_us(60);
    }
    
    return data;
}

// 获取DS18B20温度数据
float DS18B20_GetTemp(void)
{
    
    
    uint8_t tempLSB, tempMSB;
    int16_t tempData;
    float temperature;
    
    // 发送温度转换命令
    DS18B20_WriteByte(0xCC);     // 跳过ROM操作
    DS18B20_WriteByte(0x44);     // 发送温度转换命令
    
    // 等待温度转换完成
    while (!GPIO_ReadInputDataBit(DS18B20_GPIO_PORT, DS18B20_GPIO_PIN));
    
    // 发送读取温度命令
    DS18B20_WriteByte(0xCC);     // 跳过ROM操作
    DS18B20_WriteByte(0xBE);     // 发送读取温度命令
    
    // 读取温度数据
    tempLSB = DS18B20_ReadByte();
    tempMSB = DS18B20_ReadByte();
    
    // 计算温度值
    tempData = (tempMSB << 8) | tempLSB;
    if (tempData & 0x8000)      // 温度为负数
    {
    
    
        tempData = ~tempData + 1;
        temperature = -((float)tempData / 16.0);
    }
    else                        // 温度为正数
    {
    
    
        temperature = (float)tempData / 16.0;
    }
    
    return temperature;
}

4.3 Code d'affichage OLED

Fichier principal :

#ifndef SSD1306_H
#define SSD1306_H

#include "stm32f10x.h"
#include "fonts.h"

// SSD1306显示屏参数定义
#define SSD1306_I2C_ADDR      0x78    // I2C地址
#define SSD1306_WIDTH         128     // 显示屏宽度
#define SSD1306_HEIGHT        64      // 显示屏高度

// SSD1306函数声明
void SSD1306_Init(void);
void SSD1306_Clear(void);
void SSD1306_UpdateScreen(void);
void SSD1306_GotoXY(uint16_t x, uint16_t y);
void SSD1306_Puts(const char* str, FontDef_t* font, uint8_t color);

#endif

Fichier source:

#include "ssd1306.h"
#include "i2c.h"

static uint8_t SSD1306_Buffer[SSD1306_WIDTH * SSD1306_HEIGHT / 8];

void SSD1306_Init(void)
{
    
    
    // 初始化I2C总线
    I2C_Init();
    
    // 向SSD1306发送初始化命令
    uint8_t initCommands[] = {
    
    
        0xAE,           // 关闭显示
        0xD5, 0x80,     // 设置时钟分频因子
        0xA8, 0x3F,     // 设置驱动路数
        0xD3, 0x00,     // 设置显示偏移
        0x40,           // 设置显示开始行
        0x8D, 0x14,     // 设置电荷泵
        0x20, 0x00,     // 设置内存地址模式
        0xA1,           // 设置段重定义
        0xC8,           // 设置COM扫描方向
        0xDA, 0x12,     // 设置COM引脚配置
        0x81, 0xCF,     // 设置对比度控制
        0xD9, 0xF1,     // 设置预充电周期
        0xDB, 0x40,     // 设置VCOMH电压倍率
        0xA4,           // 全局显示开启
        0xA6,           // 设置显示方式
        0xAF            // 开启显示
    };
    
    for (uint8_t i = 0; i < sizeof(initCommands); i++)
    {
    
    
        I2C_WriteByte(SSD1306_I2C_ADDR, 0x00, initCommands[i]);
    }
    
    // 清空缓冲区
    SSD1306_Clear();
    
    // 更新显示屏
    SSD1306_UpdateScreen();
}

void SSD1306_Clear(void)
{
    
    
    memset(SSD1306_Buffer, 0x00, sizeof(SSD1306_Buffer));
}

void SSD1306_UpdateScreen(void)
{
    
    
    for (uint8_t i = 0; i < 8; i++)
    {
    
    
        I2C_WriteBuffer(SSD1306_I2C_ADDR, 0x40, &SSD1306_Buffer[SSD1306_WIDTH * i], SSD1306_WIDTH);
    }
}

void SSD1306_GotoXY(uint16_t x, uint16_t y)
{
    
    
    if (x >= SSD1306_WIDTH || y >= SSD1306_HEIGHT)
        return;
    
    SSD1306_Buffer[(x + (y / 8) * SSD1306_WIDTH)] |= (1 << (y % 8));
}

void SSD1306_Puts(const char* str, FontDef_t* font, uint8_t color)
{
    
    
    while (*str)
    {
    
    
        for (uint8_t i = 0; i < font->FontWidth; i++)
        {
    
    
            uint8_t temp = font->data[(*str - 32) * font->FontWidth + i];
            for (uint8_t j = 0; j < font->FontHeight; j++)
            {
    
    
                if (temp & (1 << j))
                {
    
    
                    SSD1306_GotoXY(font->FontWidth * i + j, font->FontHeight * i + j);
                    SSD1306_Buffer[(font->FontWidth * i + j + (font->FontHeight * i + j) / 8 * SSD1306_WIDTH)] |= (1 << ((font->FontHeight * i + j) % 8));
                }
                else
                {
    
    
                    SSD1306_GotoXY(font->FontWidth * i + j, font->FontHeight * i + j);
                    SSD1306_Buffer[(font->FontWidth * i + j + (font->FontHeight * i + j) / 8 * SSD1306_WIDTH)] &= ~(1 << ((font->FontHeight * i + j) % 8));
                }
            }
        }
        
        str++;
    }
}

5. Résumé

Ce projet conçoit un système de contrôle de la température d'une serre à fleurs basé sur STM32. En utilisant des modules matériels tels que le capteur de température DS18B20, l'écran OLED et le relais, la température dans la serre est surveillée et contrôlée. Le système peut contrôler automatiquement le chauffage du ventilateur à air chaud en fonction du seuil de température prédéfini pour maintenir la température appropriée dans la serre afin d'assurer l'environnement de croissance des fleurs.

En termes de conception logique logicielle, des périphériques STM32 et des mécanismes d'interruption sont utilisés, combinés avec des algorithmes et des jugements d'état appropriés, pour réaliser l'acquisition et la comparaison des données de température et contrôler la commutation du relais en fonction des résultats. Grâce à l'écran OLED et au port série USART, la valeur et le seuil de température peuvent être renvoyés à l'utilisateur en temps opportun, ce qui permet à l'utilisateur de comprendre plus facilement l'environnement actuel et d'effectuer des ajustements.

La conception et la mise en œuvre de ce projet fournissent une solution spécifique pour le système de contrôle de la température des serres. Grâce à une sélection matérielle raisonnable et à une conception logique logicielle, il peut répondre aux besoins de contrôle de la température de la plantation de fleurs. Dans le développement futur, le système jouera un rôle important dans le domaine agricole et créera un environnement à température contrôlée plus confortable et plus efficace pour les personnes.