STM32F103C8T6--BMP180+DHT11定时中断OLED串口显示信息（标准库）

再不学习就完蛋啦

已于 2025-03-03 20:55:48 修改

阅读量1k

点赞数 25

文章标签： stm32 单片机嵌入式硬件

于 2025-03-03 20:48:06 首次发布

本文链接：https://blog.csdn.net/m0_58845368/article/details/145991804

版权

OLED显示如图所示，DHT11上面是温度，下面是湿度，BMP180上面是海拔，下面是大气压

串口信息如图所示，输入数字几，串口每隔几秒输出打印一次

一开始想要实现我在串口输入数字几，串口就每隔几秒输出打印一次，本来用Delay改变延迟来实现，但是Delay的缺陷就在于是堵塞式的，在延时期间，CPU一直空转等待，无法执行其他任务，用定时器加中断就会更好，同时为了显示效果更好，OLED上只显示了部分信息。DHT11和BMP180这两个传感器的介绍见前两个文章，完整代码网盘链接：通过网盘分享的文件：BMP180+DHT11 - 定时串口OLED显示信息.zip
链接: https://pan.baidu.com/s/1mEVG0GHykgDwfZrUHjvEtQ?pwd=p9hr 提取码: p9hr

main.c

#include "LED.h"
#include "delay.h"
#include "sys.h"
#include "usart.h" 
#include "bmp180.h" 
#include "OLED.h"
#include "string.h"
#include "DHT11.h"
#include "Timer.h"
#include <stdlib.h>

************************************************/

#define CMD_OFF "off"        // 定义 "off" 命令字符串

u8 temp;
u8 humi;

typedef enum {
    WAITING_FOR_COMMAND,
    READING_DATA
} SystemState;


SystemState systemState = WAITING_FOR_COMMAND; // 系统状态变量，初始状态为等待命令
u16 numint = 3;

extern _bmp180 bmp180; // 声明在 bmp180.c 中定义的全局变量
extern volatile u8 timer_flag;

int main(void)
{
    Stm32_Clock_Init();                                      
    delay_init();
    uart_init(115200);
    OLED_Init();
    LED_Init ();
    DHT11_Init();
    IIC_Init();        // 初始化IIC，确保在BMP_Init之前调用, 假设 iic.c 中有 IIC_Init() 函数
    BMP_Init();        // BMP180 初始化
    BMP_ReadCalibrationData(); // 读取BMP180校准参数

//    u16 ID = 0x55;

    Timer_Init(1000);//初始化定时器，默认1s间隔

    printf("请输入命令数字设置数据读取间隔...\r\n"); // 提示用户发送数字命令

    OLED_ShowString(1, 1, "DHT11:");
    OLED_ShowString(3, 1, "BMP180:");

    while (1)        
    {
        
        if (systemState == WAITING_FOR_COMMAND)
{
    if (USART_RX_STA & 0x8000)
    {
        USART_RX_BUF[USART_RX_STA & 0X3FFF] = '\0';
        int input_number = atoi((char *)USART_RX_BUF); // 使用 atoi() 将接收到的字符串转换为整数
        if (input_number > 0) // 输出大于0的数字
        {
                    numint = input_number; // 将输入的数字设置为时间间隔 (秒)
                    printf("收到命令 '%d',数据每 %d 秒读取一次...\r\n",numint, numint);
                    systemState = READING_DATA; // 切换到数据读取状态
                    LED_ON ();    
        }
         else if (strcmp((char *)USART_RX_BUF, CMD_OFF) == 0)
            {            
                printf(" 收到命令 'off'，停止读取数据...\r\n");
                systemState = WAITING_FOR_COMMAND; // 返回等待命令状态
                LED_OFF ();
            }                        
//         else 
//         {
//             printf ("收到未知命令，请发送完整数字设置间隔秒数");
//         }
//         USART_RX_STA  = 0;
//         memset (USART_RX_BUF , 0, sizeof (USART_RX_BUF ));
    }
}
        else if (systemState == READING_DATA)
        {
            if (USART_RX_STA & 0x8000)
            {
                USART_RX_BUF[USART_RX_STA & 0X3FFF] = '\0';
                if (strcmp((char *)USART_RX_BUF, CMD_OFF) == 0) // 比较接收到的字符串是否为 "off"
                {
                    printf("收到命令 'off'，结束读取数据...\r\n");
                    systemState = WAITING_FOR_COMMAND ; // 切换到数据读取状态
                    LED_OFF ();    
                    USART_RX_STA = 0;
                    memset (USART_RX_BUF  , 0 ,sizeof (USART_RX_BUF ));
                    continue ;
                 }
                 USART_RX_STA  = 0 ;
                 memset (USART_RX_BUF  , 0 ,sizeof (USART_RX_BUF ));
            }
            if (timer_flag == 1)
            {
                timer_flag = 0;
                BMP_UncompemstatedToTrue ();
                
            if (DHT11_Read_Data(&temp, &humi) == 0)
                {
                printf("DHT11:\r\n Temp = %d.%dC\r\n Humi = %d%%\r\n", temp, temp % 10, humi);
                OLED_ShowNum(1, 8, temp, 2);
                OLED_ShowString(1, 10, ".");
                OLED_ShowNum(1, 11, temp % 10, 1);
                OLED_ShowString(1, 12, "C");
                OLED_ShowNum(2, 8, humi, 2);
                OLED_ShowString(2, 10, "%");
                }
                printf("BMP180:\r\n Pressure = %ldPa \r\n Altitude = %.1fm\r\n", bmp180.p, bmp180.altitude);
                OLED_ShowNum(3, 8, bmp180.altitude, 2);
                OLED_ShowString(3, 10, "m");
                OLED_ShowNum(4, 8, bmp180.p, 6);
                OLED_ShowString(4, 14, "Pa");
            }  
        }            
    }
}

Timer.c

#include "stm32f10x.h"                  // Device header

volatile u8 timer_flag = 0; // 定时器中断标志，用于通知主循环
extern u16 numint;

void Timer_Init(void)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // 使能 TIM2 时钟

    TIM_TimeBaseStructure.TIM_Prescaler = 7200 - 1;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;       // 向上计数模式
    TIM_TimeBaseStructure.TIM_Period = 10000 - 1;            
                                                             
    
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); // 使能 TIM2 更新中断
    TIM_Cmd(TIM2, ENABLE);                     // 使能 TIM2 定时器

    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;         // TIM2 中断通道
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 抢占优先级 0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;      // 子优先级 1
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             // 使能中断通道
    NVIC_Init(&NVIC_InitStructure);
}

void TIM2_IRQHandler(void)
{
    static u16 num = 0;
    
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET) // 检查是否是更新中断
    {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update); // 清除中断标志
        num ++;
        if (num >= numint)
        {
         num = 0;
         timer_flag = 1;  
        }
    }
}

Timer.h

#ifndef __TIMER_H
#define __TIMER_H

#include "stm32f10x.h"

// 定时器初始化函数
void Timer_Init(u16 period); // period 单位为 1ms 的倍数，例如 period = 5000 表示 5 秒
//void TIM2_IRQHandler(void);

#endif /* __TIMER_H */

usart.c

#include "sys.h"
#include "usart.h"      


//
//加入以下代码,支持printf函数,而不需要选择use MicroLIB      
#if 1
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
    int handle; 

}; 

FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
//_sys_exit(int x) 
//{ 
//    x = x; 
//} 
void sys_exit(int x) 
{ 
    x = x; // 显式声明返回类型为void
}

//重定义fputc函数 
int fputc(int ch, FILE *f)
{      
    while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
    return ch;
}
#endif 

/*使用microLib的方法*/
 /* 
int fputc(int ch, FILE *f)
{
    USART_SendData(USART1, (uint8_t) ch);

    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}    
   
    return ch;
}
int GetKey (void)  { 

    while (!(USART1->SR & USART_FLAG_RXNE));

    return ((int)(USART1->DR & 0x1FF));
}
*/
 
#if EN_USART1_RX   //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误       
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，    接收完成标志
//bit14，    接收到0x0d
//bit13~0，    接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记      
  
void uart_init(u32 bound){
  //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
     
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);    //使能USART1，GPIOA时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);    //开启GPIOA的时钟
    //USART1_TX   GPIOA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
   
  //USART1_RX      GPIOA.10初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
 // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  

  //Usart1 NVIC 配置
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;        //子优先级3
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
    NVIC_Init(&NVIC_InitStructure);    //根据指定的参数初始化VIC寄存器
  
   //USART 初始化设置

    USART_InitStructure.USART_BaudRate = 115200;//串口波特率
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;    //收发模式

    USART_Init(USART1, &USART_InitStructure); //初始化串口1
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    USART_Cmd(USART1, ENABLE);                    //使能串口1 

}

void USART1_IRQHandler(void)                    //串口1中断服务程序
    {
    u8 Res;
#if SYSTEM_SUPPORT_OS         //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
    OSIntEnter();    
#endif
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
        {
        Res =USART_ReceiveData(USART1);    //读取接收到的数据
        
        if((USART_RX_STA&0x8000)==0)//接收未完成
            {
            if(USART_RX_STA&0x4000)//接收到了0x0d
                {
                if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
                else USART_RX_STA|=0x8000;    //接收完成了 
                }
            else //还没收到0X0D
                {    
                if(Res==0x0d)USART_RX_STA|=0x4000;
                else
                    {
                    USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
                    USART_RX_STA++;
                    if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收      
                    }         
                }
            }            
     } 
#if SYSTEM_SUPPORT_OS     //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
    OSIntExit();                                               
#endif
} 
#endif

usart.h

#ifndef __USART_H
#define __USART_H
#include "stdio.h"	
#include "sys.h" 
#define USART_REC_LEN  			200  	//定义最大接收字节数 200
#define EN_USART1_RX 			1		//使能（1）/禁止（0）串口1接收
	  	
extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 
extern u16 USART_RX_STA;         		//接收状态标记	
//如果想串口中断接收，请不要注释以下宏定义
void uart_init(u32 bound);
#endif