蓝桥杯嵌入式第七届决赛-温、湿度监控设备

其他 2020-04-09 14:16:48 阅读次数: 0

一、题目
在这里插入图片描述
二、代码
1.初始化函数
tx.c

#include "tx.h"

void LED_Init(void){
  GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD, ENABLE);
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin = 0xff00;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
  
  GPIOD->ODR|=(1<<2);
  GPIOC->ODR|=0xff00;
  GPIOD->ODR&=~(1<<2);
}

void KEY_Init(void){
  GPIO_InitTypeDef   GPIO_InitStructure;
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB, ENABLE);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
	
}

u8 key_status[4]={1,1,1,1};

void KEY_Driver(void){
  u8 i;
  static u8 backup[4]={1,1,1,1};
  for(i=0;i<4;i++){
	if(backup[i]!=key_status[i]){
	  if(backup[i]!=0){
		Key_action(i+1);  
	  }	
	  backup[i]=key_status[i];
	}  	  
  }  
}

void KEY_Scan(void){
  u8 i;
  static u8 Key_buf[4]={0xff,0xff,0xff,0xff};
  Key_buf[0]=(Key_buf[0]<<1)|KEY1;
  Key_buf[1]=(Key_buf[1]<<1)|KEY2;
  Key_buf[2]=(Key_buf[2]<<1)|KEY3;
  Key_buf[3]=(Key_buf[3]<<1)|KEY4;
  for(i=0;i<4;i++){
	if(Key_buf[i]==0x00)  
	  key_status[i]=0; 
    else if(Key_buf[i]==0xff)  
	  key_status[i]=1;  
  }
}

void Tim4_Init(u16 arr,u16 psc){
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
  
  NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  
  TIM_TimeBaseStructure.TIM_Period = arr-1;
  TIM_TimeBaseStructure.TIM_Prescaler = psc-1;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
  TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
  TIM_Cmd(TIM4, ENABLE);	
	
}

void Adc1_Init(void){
  ADC_InitTypeDef ADC_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB, ENABLE);
  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
  
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 1;
  ADC_Init(ADC1, &ADC_InitStructure);
  ADC_Cmd(ADC1, ENABLE);

  /* Enable ADC1 reset calibration register */   
  ADC_ResetCalibration(ADC1);
  /* Check the end of ADC1 reset calibration register */
  while(ADC_GetResetCalibrationStatus(ADC1));

  /* Start ADC1 calibration */
  ADC_StartCalibration(ADC1);
  /* Check the end of ADC1 calibration */
  while(ADC_GetCalibrationStatus(ADC1));	
	
}

u16 Get_adc(void){
  u16 temp;
  ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_239Cycles5);	
  ADC_SoftwareStartConvCmd(ADC1, ENABLE); 	
  while(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC)==0);
  temp=ADC_GetConversionValue(ADC1);
  ADC_SoftwareStartConvCmd(ADC1, DISABLE);
  return temp;
}

void RTC_Init(u8 HH,u8 MM,u8 SS){
  NVIC_InitTypeDef NVIC_InitStructure; 
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
  NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

  /* Allow access to BKP Domain */
  PWR_BackupAccessCmd(ENABLE);

  /* Reset Backup Domain */
  BKP_DeInit();

  /* Enable the LSI OSC */
  RCC_LSICmd(ENABLE);
  /* Wait till LSI is ready */
  while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
  {}
  /* Select the RTC Clock Source */
  RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);

  /* Enable RTC Clock */
  RCC_RTCCLKCmd(ENABLE);

  /* Wait for RTC registers synchronization */
  RTC_WaitForSynchro();

  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();

  /* Enable the RTC Second */
  RTC_ITConfig(RTC_IT_SEC, ENABLE);

  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();

  /* Set RTC prescaler: set RTC period to 1sec */
  RTC_SetPrescaler(40000-1);

  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
  RTC_SetCounter(3600*HH+60*MM+SS);
  RTC_WaitForLastTask();	
	
}


//输出
void Tim2_Init(u32 fre,u8 duty){
  u32 arr;

  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  TIM_OCInitTypeDef  TIM_OCInitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;  
  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  
  arr=1000000/fre;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  
  TIM_TimeBaseStructure.TIM_Period = arr-1;
  TIM_TimeBaseStructure.TIM_Prescaler = 71;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; 
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = (arr-1)*duty/100;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;	  
  TIM_OC2Init(TIM2, &TIM_OCInitStructure);	    
  TIM_ITConfig(TIM2, TIM_IT_CC2, ENABLE);

  /* TIM2 enable counter */
  TIM_Cmd(TIM2, ENABLE);
}

//输入
void Tim3_Init(void){
  TIM_ICInitTypeDef  TIM_ICInitStructure;
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  /* GPIOA and GPIOB clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOA, &GPIO_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  TIM_TimeBaseStructure.TIM_Period = 0xffff;
  TIM_TimeBaseStructure.TIM_Prescaler = 71;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; 
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
  
  TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
  TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter = 0x0;

  TIM_ICInit(TIM3, &TIM_ICInitStructure);
  
  /* TIM enable counter */
  TIM_Cmd(TIM3, ENABLE);

  /* Enable the CC2 Interrupt Request */
  TIM_ITConfig(TIM3, TIM_IT_CC2, ENABLE);	
	
}

void Usart2_Init(void){
  USART_InitTypeDef USART_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); 

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  USART_InitStructure.USART_BaudRate = 9600;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  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(USART2, &USART_InitStructure);
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
  USART_Cmd(USART2, ENABLE);   
}

void Send_string(u8 *str){
  u8 i=0;
  while(str[i]!=0){
  	USART_SendData(USART2,str[i]);
	while(USART_GetFlagStatus(USART2,USART_FLAG_TXE)==0);
	i++;
  }
}

tx.h

/*
  程序说明: CT117E嵌入式竞赛板LCD驱动程序
  软件环境: Keil uVision 4.10 
  硬件环境: CT117E嵌入式竞赛板
  日    期: 2011-8-9
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __TX_H
#define __TX_H

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"


#define KEY1 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
#define KEY2 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8)
#define KEY3 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)
#define KEY4 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2)

extern void Key_action(int code);

void LED_Init(void);
void KEY_Init(void);
void KEY_Driver(void);
void KEY_Scan(void);
void Tim4_Init(u16 arr,u16 psc);
void Adc1_Init(void);
u16 Get_adc(void);
void RTC_Init(u8 HH,u8 MM,u8 SS);
void Tim2_Init(u32 fre,u8 duty);
void Tim3_Init(void);
void Usart2_Init(void);
void Send_string(u8 *str);


#endif /* __TX_H */

/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

2.中断函数
stm32f10x_it.h

void SysTick_Handler(void)
{
	TimingDelay--;
}

extern u8 ms200_flag;
extern u8 record_flag;
extern u16 record_time;

void TIM4_IRQHandler(void)
{
  static u16 ms200_count=0;
  static u16 s1_count=0;
  static u16 record_count=0;
  
  if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
  {
    TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
	KEY_Scan();
    ms200_count++;
	s1_count++;
	if(ms200_count>=100){
		ms200_count=0;
		ms200_flag=1;
	}
	if(s1_count>=500){
		s1_count=0;
		record_count++;
		if(record_count>=record_time){
			record_flag=1;
			record_count=0;
		}
	}
  }
}

extern u16 time;
extern u8 hour,min,sec;
void RTC_IRQHandler(void)
{
  if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
  {	  	
    RTC_ClearITPendingBit(RTC_FLAG_SEC);
	time=RTC_GetCounter();
	if(time==23*3600+59*60+59)
	  RTC_SetCounter(0);
	hour=time/3600;
	min=time%3600/60;
	sec=time%3600%60;
  }
}

__IO uint16_t IC3ReadValue1 = 0, IC3ReadValue2 = 0;
__IO uint16_t CaptureNumber = 0;
__IO uint32_t Capture = 0;
__IO uint32_t TIM3Freq = 0;

void TIM3_IRQHandler(void)
{ 
  if(TIM_GetITStatus(TIM3, TIM_IT_CC2) == SET) 
  {
    /* Clear TIM3 Capture compare interrupt pending bit */
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
    if(CaptureNumber == 0)
    {
      /* Get the Input Capture value */
      IC3ReadValue1 = TIM_GetCapture2(TIM3);
      CaptureNumber = 1;
    }
    else if(CaptureNumber == 1)
    {
      /* Get the Input Capture value */
      IC3ReadValue2 = TIM_GetCapture2(TIM3); 
      
      /* Capture computation */
      if (IC3ReadValue2 > IC3ReadValue1)
      {
        Capture = (IC3ReadValue2 - IC3ReadValue1); 
      }
      else
      {
        Capture = ((0xFFFF - IC3ReadValue1) + IC3ReadValue2); 
      }
      /* Frequency computation */ 
      TIM3Freq = 1000000 / Capture;
      CaptureNumber = 0;
    }
  }
}

extern u8 RXD_flag;
extern u8 RXD_buf[20];
u16 RXD_count=0;

void USART2_IRQHandler(void)
{
  u16 temp;
  if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
  {
    USART_ClearITPendingBit(USART2, USART_IT_RXNE) ;
    temp=USART_ReceiveData(USART2);
	if(temp=='\n'){
	   RXD_flag=1;
	   RXD_count=0;
	   USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
	}
    else
	  RXD_buf[RXD_count++]=temp;
  }
}

3.主函数
main.c

#include "stm32f10x.h"
#include "lcd.h"
#include "tx.h"
#include "stdio.h"
#include "i2c.h"

u32 TimingDelay = 0;

extern __IO uint32_t TIM3Freq;

u8 time;	  //时间
u8 hour,min,sec;

float adc_value; //电压值

u8 ms200_flag=1;
u8 record_flag=0;	 //采集数据标志
u16 record_time=1;	 //采集间隔
u16 get_time=0;	  //采集次数
u16 get_t=0;	  //缓存数据条数

u8 RXD_flag;
u8 RXD_buf[20];
u8 str[20];
u8 i;

u8 SET_flag=0;//0-实时数据，1-设置界面
u8 Index_flag=0;//0-温度上限...参数设置

float temp=0;	  //温度
u16 humi=0;		  //湿度
float temp_door=40;	  //阈值
u16 humi_door=80;
float test_fre;	   //测试信号

int record[70][6]={0}; //记录多次温湿度数据

u16 LED_MODE=0xffff;
u8 LED1_flag=0;
u8 LED2_flag=0;
u8 LED3_flag=0;

void Refresh(void);
void Show_realdata(void);
void Show_setdata(void);
void Led_actin(void);
void Record_action(void);
void Usart2_action(void);
void Key_action(int code);
void In_data(void);
void De_data(void);
void Delay_Ms(u32 nTime);

//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);

	Delay_Ms(200);
	
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(Blue);
	LCD_SetTextColor(White);
	
	i2c_init();
	LED_Init();
	KEY_Init();
	Tim4_Init(2000,72);
	Adc1_Init();
	RTC_Init(12,50,50);
	Tim3_Init();
	Usart2_Init();
	

	if(i2c_read(0x00)) {
	  temp_door=-i2c_read(0x01);Delay_Ms(5);
	}
	else{
	  temp_door=i2c_read(0x01);Delay_Ms(5);
	}  
	humi_door=i2c_read(0x02);Delay_Ms(5);
	record_time=i2c_read(0x03);Delay_Ms(5);
	test_fre=i2c_read(0x04)/10;Delay_Ms(5);

	while(1){
	  KEY_Driver();
	  if(ms200_flag){
	    ms200_flag=0;
		Refresh();
		Led_actin();
		if(SET_flag==0)
		  Show_realdata();
		else
		  Show_setdata(); 		 
	  }
	  if(record_flag){
	  	record_flag=0;
		Record_action();
	  }
	  if(RXD_flag){
	    RXD_flag=0;
		Usart2_action();
	  }
	}
}

void Refresh(void){
  
  adc_value=Get_adc()*3.3/4096;
  temp=adc_value*80/3.3-20;
  humi=(80*TIM3Freq/1000+10)/9;

  if(temp>=temp_door)
    LED1_flag=1;
  if(humi>=humi_door)
    LED2_flag=1;
}

void Show_realdata(void){
  sprintf((char*)str,"     Real Data   ");
  LCD_DisplayStringLine(Line1, str);

  if(temp<0){
  	sprintf((char*)str,"  Temp: %.0fC       ",-temp);
    LCD_DisplayStringLine(Line3, str);
  }
  else {
  	sprintf((char*)str,"  Temp: %.0fC       ",temp);
    LCD_DisplayStringLine(Line3, str);
  }

  sprintf((char*)str,"  Humi: %d%%     ",humi);
  LCD_DisplayStringLine(Line5, str);

  sprintf((char*)str,"  Time: %.2d-%.2d-%.2d   ",hour,min,sec);
  LCD_DisplayStringLine(Line7, str);

  sprintf((char*)str,"  Record: %d            ",get_time);
  LCD_DisplayStringLine(Line9, str);
}

void Show_setdata(void){
  sprintf((char*)str,"    Para Setting   ");
  LCD_DisplayStringLine(Line1, str);

  if(Index_flag==0)
    LCD_SetTextColor(Green);
  else
    LCD_SetTextColor(White);
  
  if(temp_door<0){
  	sprintf((char*)str,"  Temp_thr:  %.0fC   ",temp_door);
    LCD_DisplayStringLine(Line3, str);
  }
  else {
  	sprintf((char*)str,"  Temp_thr:  %.0fC   ",temp_door);
    LCD_DisplayStringLine(Line3, str);
  }

  if(Index_flag==1)
    LCD_SetTextColor(Green);
  else
    LCD_SetTextColor(White);
  sprintf((char*)str,"  Humi_thr:  %d%%  ",humi_door);
  LCD_DisplayStringLine(Line5, str);

  if(Index_flag==2)
    LCD_SetTextColor(Green);
  else
    LCD_SetTextColor(White);
  sprintf((char*)str,"  Re_time:   %ds  ",record_time);
  LCD_DisplayStringLine(Line7, str);

  if(Index_flag==3)
    LCD_SetTextColor(Green);
  else
    LCD_SetTextColor(White);
  sprintf((char*)str,"  Signal:    %.1fkHz  ",test_fre);
  LCD_DisplayStringLine(Line9, str);
  
  LCD_SetTextColor(White);
}

void Led_actin(void){
  if(LED1_flag){
  	LED1_flag=0;
	LED_MODE^=(1<<8);
	GPIOC->ODR=LED_MODE;
	GPIOD->ODR|=(1<<2);
    GPIOD->ODR&=~(1<<2);
  }
  else if(LED1_flag==0){
  	LED1_flag=0;
	LED_MODE|=(1<<8);
	GPIOC->ODR=LED_MODE;
	GPIOD->ODR|=(1<<2);
    GPIOD->ODR&=~(1<<2);
  }
  if(LED2_flag){
  	LED2_flag=0;
	LED_MODE^=(1<<9);
	GPIOC->ODR=LED_MODE;
	GPIOD->ODR|=(1<<2);
    GPIOD->ODR&=~(1<<2);
  }
  if(LED2_flag){
  	LED2_flag=0;
	LED_MODE|=(1<<9);
	GPIOC->ODR=LED_MODE;
	GPIOD->ODR|=(1<<2);
    GPIOD->ODR&=~(1<<2);
  }
}

void Record_action(void){
  get_time++;
  record[get_time][0]=temp;
  record[get_time][1]=humi;
  record[get_time][2]=hour;
  record[get_time][3]=min;
  record[get_time][4]=sec;
  if(get_time>=65)
    get_time=0;

  LED_MODE^=(1<<10);
  GPIOC->ODR=LED_MODE;
  GPIOD->ODR|=(1<<2);
  GPIOD->ODR&=~(1<<2);
}

void Usart2_action(void){
  u8 j;
  if(RXD_buf[0]=='C'){
  	sprintf((char*)str,"Temp_thr:%.0fC   Humi_thr:%d%%   %.2d-%.2d-%.2d\r\n",temp_door,humi_door,hour,min,sec);
    Send_string(str);
  }
  else if(RXD_buf[0]=='T'){
  	get_t=get_time;
	Delay_Ms(200);
	for(j=0;j<get_t;j++){
	  sprintf((char*)str,"%d   Temp:%dC   Humi:%d%%   %.2d-%.2d-%.2d\r\n",j,record[j][0],record[j][1],record[j][2],record[j][3],record[j][4]);
      Send_string(str);
	}
  }
  for(i=0;i<20;i++)
    RXD_buf[i]=0;
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
}

void Key_action(int code){
  if(code==1){
  	 SET_flag^=1;
	 if(SET_flag==0){
	   if(temp_door<0){
	   	 i2c_write(0x00,1);Delay_Ms(5);
		 i2c_write(0x01,-temp_door); Delay_Ms(5);
	   }
	   else{
	   	 i2c_write(0x00,0);Delay_Ms(5);
		 i2c_write(0x01,temp_door); Delay_Ms(5);
	   }	  	   
	   i2c_write(0x02,humi_door); Delay_Ms(5);
	   i2c_write(0x03,record_time); Delay_Ms(5);
	   i2c_write(0x04,test_fre*10); Delay_Ms(5);
	   Tim2_Init(test_fre*1000,50);
	 }
  }
  else if(code==2){
    if(SET_flag==1){
	  Index_flag++;
	  if(Index_flag>3)
	    Index_flag=0;
	}
  }
  else if(code==3){
  	if(SET_flag==1)
	  In_data();
  }
  else if(code==4){
  	if(SET_flag==1)
	  De_data();
  }
}

void In_data(void){
  if(Index_flag==0){
  	temp_door++;
	if(temp_door>=60)
	  temp_door=60;
  }
  else if(Index_flag==1){
  	humi_door++;
	if(humi_door>90)
	  humi_door=90;
  }
  else if(Index_flag==2){
  	record_time++;
	if(record_time>5)
	  record_time=1;
  }
  else if(Index_flag==3){
    test_fre+=0.5;
	if(test_fre>10)
	  test_fre=10;
  }
}

void De_data(void){
  if(Index_flag==0){
  	temp_door--;
	if(temp_door<-20)
	  temp_door=-20;
  }
  else if(Index_flag==1){
  	humi_door--;
	if(humi_door<10)
	  humi_door=10;
  }
  else if(Index_flag==2){
  	record_time--;
	if(record_time<=0)
	  record_time=5;
  }
  else if(Index_flag==3){
    test_fre-=0.5;
	if(test_fre<1)
	  test_fre=1;
  }
} 

void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

有一点需要注意的是，温度为负数的时候，存储与处理都要考虑符号。

fancyZT
发布了31 篇原创文章 · 获赞 12 · 访问量 4404
私信 关注

猜你喜欢

转载自blog.csdn.net/fancyZT/article/details/105409463
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022