I. Introducción
A medida que la demanda popular por el cultivo de flores continúa creciendo, la construcción y gestión de invernaderos de flores se ha convertido en un tema importante. En los invernaderos de flores, la temperatura es un parámetro ambiental crucial que tiene un impacto directo en el crecimiento y desarrollo de las flores. Para proporcionar un entorno de crecimiento estable, resulta muy importante controlar la temperatura del invernadero.
Este proyecto diseña un sistema de control de temperatura para invernaderos de flores basado en un microcontrolador STM32. El sistema utiliza STM32F103C8T6 como chip de control principal para monitorear y controlar la temperatura en el invernadero mediante la conexión con módulos de hardware como el sensor de temperatura DS18B20 y la pantalla OLED de 0,96 pulgadas. Al mismo tiempo, el sistema también está equipado con dos botones independientes para configurar el umbral de temperatura.
El sensor de temperatura utiliza DS18B20, que puede controlar con precisión la temperatura en el invernadero. Los datos de temperatura se pueden obtener en tiempo real mediante la comunicación con el microcontrolador STM32. La pantalla utiliza una pantalla OLED de 0,96 pulgadas con protocolo SPI, que se utiliza para mostrar la temperatura del entorno actual y el umbral de temperatura. Los usuarios pueden configurar el umbral de temperatura a través de botones para que el sistema pueda controlar la temperatura de acuerdo con el umbral establecido.
Cuando la temperatura es inferior al umbral de temperatura establecido, el sistema controlará el ventilador de aire caliente a través del relé para calentar y expulsar aire caliente para controlar la temperatura ambiente. Al monitorear la temperatura en tiempo real y controlarla según el umbral establecido, el sistema puede mantener la temperatura en el invernadero dentro de un rango adecuado y proporcionar un entorno de crecimiento estable para las flores.
El proyecto está diseñado para aumentar la automatización de los invernaderos de flores y reducir la carga de la gestión manual, al tiempo que proporciona una solución de control de temperatura estable para promover el crecimiento y desarrollo de las flores. Al utilizar microcontroladores STM32 y módulos de hardware relacionados, el sistema puede lograr monitoreo en tiempo real y control automático de la temperatura, brindando una solución conveniente y eficiente para los administradores de invernaderos de flores.
El diagrama final del modelo del sistema después de agregar el control remoto:
2. Introducción a la selección de hardware.
La siguiente es la selección de hardware del sistema de control de temperatura del invernadero de flores basado en STM32:
【1】Chip de control principal: STM32F103C8T6
- La serie STM32F103 tiene buen rendimiento y numerosos periféricos, lo que la hace adecuada para aplicaciones integradas.
- STM32F103C8T6 es un microcontrolador de núcleo ARM Cortex-M3 de 32 bits con memoria Flash de 64 KB y RAM de 20 KB.
【2】Sensor de temperatura: DS18B20
- DS18B20 es un sensor de temperatura digital que utiliza una única interfaz de bus para la comunicación.
- Tiene las características de alta precisión, resistente al agua y al polvo, y es muy adecuado para medir la temperatura en invernadero.
- Conéctese al puerto GPIO de STM32 a través de pines y use el protocolo OneWire para la comunicación de datos.
【3】Pantalla: pantalla OLED de 0,96 pulgadas
- Elija una pantalla OLED de 0,96 pulgadas que admita el protocolo SPI como dispositivo de visualización, que puede mostrar fácilmente la temperatura ambiente y el umbral de temperatura.
- Las pantallas OLED tienen las ventajas de un bajo consumo de energía, un alto contraste y amplios ángulos de visión, lo que las hace adecuadas para aplicaciones integradas.
【4】Botones: dos botones independientes
- Seleccione dos botones independientes para configurar el umbral de temperatura, que se puede aumentar o disminuir presionando el botón.
【5】Relé: se utiliza para controlar la calefacción del ventilador de aire caliente.
- Según el umbral de temperatura y los datos de temperatura en tiempo real, el interruptor del relé se controla a través del puerto GPIO de STM32 para controlar el calentamiento del ventilador de aire caliente.
- La selección del relé debe determinarse en función de la corriente nominal y el voltaje del soplador de aire caliente para garantizar un funcionamiento normal.
3. Ideas de diseño
Ideas de diseño de lógica de software:
【1】Inicialice los periféricos STM32, incluidos GPIO, SPI, USART, etc.
【2】Establezca el valor inicial del umbral de temperatura y ajuste el umbral a través de los botones.
【3】 Bucle para leer los datos del sensor de temperatura DS18B20 y comparar el valor de temperatura leído con el valor umbral.
【4】Si la temperatura actual es inferior al umbral, el relé de control se cierra y el ventilador de aire caliente comienza a calentar; de lo contrario, el relé se abre para detener el calentamiento.
【5】Muestre el valor de temperatura y el valor umbral en la pantalla OLED y envíelos al usuario a través del puerto serie USART.
【6】 Ejecute continuamente los pasos anteriores en un ciclo para realizar la función de control automático de temperatura del invernadero.
pseudocódigo:
// 定义变量
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;
}
Las anteriores son las ideas básicas de diseño de lógica de software y pseudocódigo.
4. Implementación del código
4.1 Leer la pantalla de temperatura
El siguiente es el código de implementación para usar STM32F103C8T6 para leer los datos del sensor de temperatura DS18B20 y mostrar la temperatura en la pantalla 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);
}
}
En el código, se utilizan archivos de biblioteca empaquetados, incluidos archivos de biblioteca para la función de retardo (delay.h), bus OneWire (onewire.h), sensor de temperatura DS18B20 (ds18b20.h) y pantalla OLED SSD1306 (ssd1306.h).
En la función principal, inicialice la función de retardo y la pantalla OLED, e inicialice el sensor de temperatura DS18B20. Luego ingrese a un bucle infinito, lea los datos de temperatura del sensor de temperatura DS18B20 en el bucle y muestre la temperatura en la pantalla OLED. Los datos de temperatura se convierten en una cadena a través de la función sprintf y se muestran en la pantalla OLED usando la función de biblioteca SSD1306. Retraso por un período de tiempo a través de la función de retraso para lograr actualizaciones periódicas de la temperatura.
4.2 Código DS18B20
Código del archivo de encabezado:
#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
Código del archivo fuente:
#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 Código de pantalla OLED
Archivo de cabeza:
#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
Archivo fuente:
#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. Resumen
Este proyecto diseña un sistema de control de temperatura para invernaderos de flores basado en STM32. Mediante el uso de módulos de hardware como el sensor de temperatura DS18B20, la pantalla OLED y el relé, se monitorea y controla la temperatura en el invernadero. El sistema puede controlar automáticamente el calentamiento del ventilador de aire caliente de acuerdo con el umbral de temperatura preestablecido para mantener la temperatura adecuada en el invernadero y garantizar el entorno de crecimiento de las flores.
En términos de diseño lógico de software, se utilizan periféricos y mecanismos de interrupción STM32, combinados con algoritmos y juicios de estado apropiados, para lograr la adquisición y comparación de datos de temperatura y controlar la conmutación del relé en función de los resultados. A través de la pantalla OLED y el puerto serie USART, el valor y el umbral de temperatura se pueden enviar al usuario de manera oportuna, lo que le facilita comprender el entorno actual y realizar ajustes.
El diseño e implementación de este proyecto proporciona una solución específica para el sistema de control de temperatura de invernaderos que, mediante una selección razonable de hardware y un diseño lógico de software, puede satisfacer las necesidades de control de temperatura de la plantación de flores. En el desarrollo futuro, el sistema desempeñará un papel importante en el campo agrícola y creará un ambiente con temperatura controlada más cómodo y eficiente para las personas.