参考文献

[1] 李梦瑶，张亚峰. 基于STM32的 智能灯 设计与实现. 2022

[2] 何运繁，罗俊. 多功能 智能灯 系统的设计与实现. 2021

[3] 陈晓航，夏彬阳. 基于智能家居系统的智能台灯设计与实践. 2016

[4] 王超宇，祝忠明. 何春燕. 基于 STM32 的多功能智能护眼台灯的设计. 2019

[5] 张启龙，陈湘萍. 基于 STM32 的智能互联台灯设计. 2019

[6] 周明,王振. 基于STM32 单片机的智能床围灯设计. 2020

[7] 杨显斌. 一种基于STM32的智能学习型台灯设计. 2019  

[8] 郑瑞旭，张炎生. 基于STM32的智能交通灯控制系统设计.

[9] 贺广博，承晓. 基于STM32F030F4的护眼台灯的设计. 2017

[10]赵继文. 传感器与应用电路设计[M ]. 北京: 科学业出版社, 2002.

[11]黄继昌. 电子元器件应用手册[M ]. 北京: 人民邮电出版社, 2004.

[12]何希才. 传感器及其应用电路[M ]. 北京: 电子工业出版社, 2001.

[13]陈晓阳. 基于STM32的智能灯控系统设计与实现. 2016

[14] Li G D, Zhang J F, Zheng H G, et al. U Nong Shu Cai Tong System - The Agricultural Expert System Based on U Disk[J]. Applied Mechanics & Materials, 2013, 397-400:2406-2411.

[15] Du B, Cai C, Zhang X. Flat control system based on free pendulum[C]// International Conference on Computer Science & Education. 2012.

[16] Wang,Ting. Design of Intelligent Wagon which Can Automatically Enter into Garage Based on STC89C52[J]. Applied Mechanics & Materials, 2015, 713-715:5

致  谢

在完成这篇论文的过程中，我衷心感谢骆晓鹏老师对我的研究工作和学术成长所给予的巨大支持和帮助。同时，也感谢所有参与本研究的同行及朋友们的鼓励和支持。骆晓鹏老师不仅在学术上给予了我宝贵的指导，还在研究方法和论文撰写上提供了大量的帮助和建议。老师的严谨学风和勤奋态度一直是我学习的榜样，老师的耐心指导和鼓励让我在遇到困难和挑战时能够保持信心，继续前进。

同时，我也要感谢所有参与本研究的同行和专家。在项目的实施过程中，他们提供了大量的专业知识和实践经验，对研究的成功完成起到了关键作用。他们的热心帮助和宝贵意见让我受益匪浅。

此外，我还要感谢我的朋友们。在我进行研究和撰写论文的日子里，他们给予了我无限的支持和帮助，是我完成研究的不竭动力。

最后，我要感谢所有直接或间接为本研究贡献力量的人。感谢学校提供的优良学习和研究环境，感谢图书馆和实验室提供的资源支持，感谢所有提供技术和学术支持的机构和个人。

每一份帮助和支持都是我完成这篇论文不可或缺的一部分，我将这份成果献给所有支持和帮助过我的人。谢谢你们！

附  录

程序代码：

Main主程序

#include "sys.h"

#include "adc.h"

#include "delay.h"

#include "lcd1602.h"

#include "usart1.h"

#include "usart3.h"

#include "timer.h"

#include "gpio.h"

#include "stdio.h"

#include "stdbool.h"

#include <string.h>

#define STM32_RX1_BUF       Usart1RecBuf

#define STM32_Rx1Counter    RxCounter

#define STM32_RX1BUFF_SIZE  USART1_RXBUFF_SIZE

bool mode = 0;               //0是自动模式，1是手动模式

unsigned char miao = 0;      //没有人的计时时间

unsigned char PWM_Val = 0xFF;//用于PWM调节

unsigned char GearTemp = 0;  //0~3档

u16 light=0;

unsigned char command = 0;

unsigned char STR_BUF[]={0x0e,0x0e,0x04,0x0e,0x15,0x04,0x0a,0x11};   //特殊图形

bool usart_send_flag = 0;

bool shuaxin = 0;

void AutoModeHandle(void)//自动模式处理函数，根据光线调节LED亮度

{

  u16 test_adc=0;

   /////////////获取光线值

   test_adc = Get_Adc_Average(ADC_Channel_9,10);//读取通道9的5次AD平均值

  light = test_adc*99/4096;//转换成0-99百分比

  light = light >= 99? 99: light;//最大只能到百分之99

   LCD_Write_Char(6,0,light/10+'0');

   LCD_Write_Char(7,0,light%10+'0');

   if(mode==0)//在自动模式下，根据光线调节档位

  {

     if(miao==0)GearTemp=0;//秒计时到0，说明没有人了，关闭LED

     else//否则根据光线调节

    {

      if(light>=85)GearTemp=0;

      if(light<85)GearTemp=1;

      if(light<55)GearTemp=2;

      if(light<25)GearTemp=3;

    }

  }

}

void BRIGHTNESS(u8 index)//调节亮度

{

  switch(index)

  {

    case(0):PWM_Val = 0xFF;PWM_LED = 0;break;

    case(1):PWM_Val = 0x46;break;  //70

    case(2):PWM_Val = 0x28;break;  //40

    case(3):PWM_Val = 0x00;PWM_LED = 1;break;

    default:PWM_Val = 0x00;PWM_LED = 1;break;

  }

  LCD_Write_Char(15,0,index+'0');

}

void keyscan(void)

{

 if(KEY1 == 0)//模式切换按键

 {

   delay_ms(10);//消抖

  if(KEY1 == 0)

  {

    while(KEY1 == 0);//等待按键松开

   mode = 0;

      LCD_Write_String(0,1,"    < AUTO >    ");

  }

 }

 if(KEY2 == 0)//模式切换按键

 {

   delay_ms(10);

  if(KEY2 == 0)

  {

       while(KEY2 == 0);

       mode = 1;

       LCD_Write_String(0,1,"    <Manual>    ");

  }

 }

 if(mode == 1)

 {

   if(KEY3 == 0)//加键

   {

    delay_ms(10);

    if(KEY3 == 0 )

    {

     while(KEY3 == 0);

     if(GearTemp < 3)GearTemp++;

    }

   }

   

   if(KEY4 == 0)//减键

   {

    delay_ms(10);

    if(KEY4 == 0 )

    {

     while(KEY4 == 0);

     if(GearTemp > 0)GearTemp--;

    }

   }

 }

}

void UsartSendReceiveData(void)

{

   if(STM32_Rx1Counter > 0)

  { 

     delay_ms(20);

   

    if(strstr(STM32_RX1_BUF,"auto_mode")!=NULL)

    {

       mode = 0;

      LCD_Write_String(0,1,"    < AUTO >    ");

    } 

    

    if(strstr(STM32_RX1_BUF,"manual_mode")!=NULL)

    {

      mode = 1;

      LCD_Write_String(0,1,"    <Manual>    ");

    } 

    if(mode == 1)

    {   

      if(strstr(STM32_RX1_BUF,"manual_off")!=NULL)

      {

        GearTemp = 0;

      }

      if(strstr(STM32_RX1_BUF,"gear_one")!=NULL)

      {

        GearTemp = 1;

      } 

      if(strstr(STM32_RX1_BUF,"gear_two")!=NULL)

      {

        GearTemp = 2;

      } 

            if(strstr(STM32_RX1_BUF,"gear_three")!=NULL)

      {

        GearTemp = 3;

      }       

    }

     memset(STM32_RX1_BUF, 0, STM32_RX1BUFF_SIZE);//清除缓存

      STM32_Rx1Counter = 0;       

  }

  if(usart_send_flag==1)    //1秒钟上传一次数据

  {

     usart_send_flag = 0;  

      

     printf("$light:%d#,$gear:%d#",(int)light,(int)GearTemp);

  }

}

int main(void)

{ 

  delay_init();     //延时函数初始化   

   NVIC_Configuration();

  delay_ms(500);       //上电瞬间加入一定延时在初始化

   Adc_Init();          //ADC初始化

   KEY_GPIO_Init();    //按键初始化

   uart1_Init(9600);

  LCD_Init();         //屏幕初始化

   LCD_Write_String(0,0,"light:00%    G:0");//显示字符串

   LCD_Write_String(0,1,"    < AUTO >    ");

   memset(STM32_RX1_BUF, 0, STM32_RX1BUFF_SIZE);//清除缓存

  STM32_Rx1Counter = 0;

   USART3_Init(9600);

   TIM2_Init(99,71);     //定时器初始化，定时100us

  TIM3_Init(499,7199);  //定时器初始化，定时50ms

   //Tout = ((arr+1)*(psc+1))/Tclk ;  

   //Tclk:定时器输入频率(单位MHZ)

   //Tout:定时器溢出时间(单位us)

  while(1)

  {  

    keyscan();

    if(command!=0)

    {

      delay_ms(10);

     switch(command)

     {

      case(0x01): mode = 0;LCD_Write_String(0,1,"    < AUTO >    ");  break;

      case(0x02): mode = 1;LCD_Write_String(0,1,"    <Manual>    ");  break;  

            case(0x03): mode = 1;LCD_Write_String(0,1,"    <Manual>    ");if(mode==1) GearTemp=0;    break; 

      case(0x04): mode = 1;LCD_Write_String(0,1,"    <Manual>    ");if(mode==1) GearTemp=1;    break; 

      case(0x05): mode = 1;LCD_Write_String(0,1,"    <Manual>    ");if(mode==1) GearTemp=2;    break; 

      case(0x06): mode = 1;LCD_Write_String(0,1,"    <Manual>    ");if(mode==1) GearTemp=3;    break; 

      default: break;

     }

     command=0;

    }

    if(shuaxin == 1)//延时一段时间执行以下函数

    {

       shuaxin = 0;

            AutoModeHandle();     

    } 

    UsartSendReceiveData();

    BRIGHTNESS(GearTemp);

    if(miao>0)Lcd_Custom_Char(0,10,4,STR_BUF); //有人则显示特殊图形

    else      LCD_Write_Char(10,0,' ');        //无人显示空白符

    delay_ms(1);

  } 

}

void USART3_IRQHandler(void)              //串口1中断服务程序,用于接收语音识别模块发送过来的数据   

{

     if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  

     {   

        command = USART_ReceiveData(USART3);//接收模块的数据

     }

     if(USART_GetFlagStatus(USART3,USART_FLAG_ORE) == SET)

     {

         USART_ClearFlag(USART3,USART_FLAG_ORE);

     }

     USART_ClearITPendingBit(USART3, USART_IT_RXNE);

}

void TIM2_IRQHandler(void)//定时器2中断服务程序  

{

   static u8 timeCount = 0;

  if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) //检查指定的TIM中断发生与否:TIM 中断源

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_Update); //清除中断标志位  

     timeCount++;

     if(timeCount > 100)timeCount = 0;          //10ms一个周期 ，频率为100Hz

    if(timeCount >= PWM_Val)PWM_LED = 1;      //占空比调节  

    else PWM_LED = 0;  

   }

}

void TIM3_IRQHandler(void)   //TIM3中断,50毫秒一次中断

{

  static u8 timeCount1 = 0;

   static u8 timeCount2 = 0;

   static u8 timeCount3 = 0;

  if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET) //检查指定的TIM中断发生与否:TIM 中断源

  {

    TIM_ClearITPendingBit(TIM3, TIM_IT_Update);  //清除TIMx的中断待处理位:TIM 中断源

        if(timeCount1++ >= 20)//1秒时间到

    {

      timeCount1 = 0;

      if(SR501==1)miao=10;//检测到有人，时间赋值10秒

       else

      {

        if(miao>0)miao--;//没有人，10秒倒计时

      }

    }

    

    timeCount2++;

    if(timeCount2 >= 10)

    {

      timeCount2 = 0;

       

       shuaxin = 1;

    }

    

    timeCount3++;

    if(timeCount3 >= 13)

    {

      timeCount3 = 0;

       

       usart_send_flag = 1;

    }

  }

}

Adc模数转换程序

#include "adc.h"

 #include "delay.h"

     

//初始化ADC

//这里我们仅以规则通道为例

//我们默认将开启通道0~3                    

void  Adc_Init(void)

{  

 ADC_InitTypeDef ADC_InitStructure;

 GPIO_InitTypeDef GPIO_InitStructure;

 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB |RCC_APB2Periph_ADC1 , ENABLE );   //使能ADC1通道时钟

 RCC_ADCCLKConfig(RCC_PCLK2_Div6);   //设置ADC分频因子6 72M/6=12,ADC最大时间不能超过14M

 //PB1 作为模拟通道输入引脚                         

 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;

 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;  //模拟输入引脚

 GPIO_Init(GPIOB, &GPIO_InitStructure); 

 ADC_DeInit(ADC1);  //复位ADC1,将外设 ADC1 的全部寄存器重设为缺省值

 ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //ADC工作模式:ADC1和ADC2工作在独立模式

 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数据右对齐

 ADC_InitStructure.ADC_NbrOfChannel = 1; //顺序进行规则转换的ADC通道的数目

 ADC_Init(ADC1, &ADC_InitStructure); //根据ADC_InitStruct中指定的参数初始化外设ADCx的寄存器   

  

 ADC_Cmd(ADC1, ENABLE); //使能指定的ADC1

 ADC_ResetCalibration(ADC1); //使能复位校准  

  

 while(ADC_GetResetCalibrationStatus(ADC1)); //等待复位校准结束

 ADC_StartCalibration(ADC1);  //开启AD校准

 while(ADC_GetCalibrationStatus(ADC1));  //等待校准结束

// ADC_SoftwareStartConvCmd(ADC1, ENABLE);  //使能指定的ADC1的软件转换启动功能

}      

//获得ADC值

//ch:通道值 0~3

u16 Get_Adc(u8 ch)   

{

   //设置指定ADC的规则组通道，一个序列，采样时间

 ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5 ); //ADC1,ADC通道,采样时间为239.5周期          

  

 ADC_SoftwareStartConvCmd(ADC1, ENABLE);  //使能指定的ADC1的软件转换启动功能 

  

 while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));//等待转换结束

 return ADC_GetConversionValue(ADC1); //返回最近一次ADC1规则组的转换结果

}

u16 Get_Adc_Average(u8 ch,u8 times)

{

 u32 temp_val=0;

 u8 t;

 for(t=0;t<times;t++)

 {

  temp_val+=Get_Adc(ch);

  delay_ms(5);

 }

 return temp_val/times;

}   

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

     中位值平均滤波法（又称防脉冲干扰平均滤波法）

方法： 采一组队列去掉最大值和最小值后取平均值。

      相当于“中位值滤波法”+“算术平均滤波法”。

      连续采样N个数据，去掉一个最大值和一个最小值，

      然后计算N-2个数据的算术平均值。    

优点： 融合了“中位值滤波法”+“算术平均滤波法”两种滤波法的优点。

       对于偶然出现的脉冲性干扰，可消除由其所引起的采样值偏差。

       对周期干扰有良好的抑制作用。

       平滑度高，适于高频振荡的系统。

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

#define N 500 //设置连续采样的次数

u16 Get_Adc_filter(u8 ch)

{

    u16  filter_buf[N]; //缓存N次采样值的存储变量

    u32  filter_temp,filter_sum;           

   u16  i,j;

    for(i = 0; i < N; i++)  //连续采样N个AD值

    {

      filter_buf[i] = Get_Adc(ch);

      delay_us(50);

    }

     // 采样值从小到大排列（冒泡法）

  for(j = 0; j < N - 1; j++)

  {

   for(i = 0; i < N - 1 - j; i++)

   {

    if(filter_buf[i] > filter_buf[i + 1])

    {

     filter_temp = filter_buf[i];

     filter_buf[i] = filter_buf[i + 1];

     filter_buf[i + 1] = filter_temp;

    }

   }

  }

   // 去除最大最小极值后求平均

   for(i = 1; i < N - 1; i++)

   {

    filter_sum += filter_buf[i];

     delay_us(50);

   }

     return (u16)(filter_sum/(N-2));

}

#ifndef __ADC_H

#define __ADC_H 

#include "sys.h"

void Adc_Init(void);

u16  Get_Adc(u8 ch);

u16 Get_Adc_Average(u8 ch,u8 times);

u16 Get_Adc_filter(u8 ch);

#endif

lcd1602液晶程序

#include "lcd1602.h"

#include "delay.h"

#include "sys.h"

u8 Dao_xu(u8 data)

{

    u8 i = 0 ,temp = 0;;

   

   for(i = 0; i < 8; i++)

  {

    temp += (((data >> i) & 0x01) << (7 - i));

  }

  return temp;

}

/*------------------------------------------------

              写入命令函数

------------------------------------------------*/

void LCD_Write_Com(unsigned char com)

{                              

  LCD1602_RS=0;  //命令

 delay_us(1);

  LCD1602_RW=0;

  delay_us(1);

  LCD1602_EN=1;                  

 delay_us(1);

  GPIO_Write(GPIOA,(GPIO_ReadOutputData(GPIOA)&0XFF00)+Dao_xu(com)); //在不影响A8-A15引脚的前提下，把数据写到A0-A7引脚     

 delay_ms(1);

  LCD1602_EN=0;

}

/*------------------------------------------------

              写入数据函数

------------------------------------------------*/

 void LCD_Write_Data(unsigned char Data)

{                                  

  LCD1602_RS=1;   //数据              

 delay_us(1);

  LCD1602_RW=0;

  delay_us(1); 

  LCD1602_EN=1;                  

 delay_us(1);

  GPIO_Write(GPIOA,(GPIO_ReadOutputData(GPIOA)&0XFF00)+Dao_xu(Data)); //在不影响A8-A15引脚的前提下，把数据写到A0-A7引脚   

 delay_ms(1);

  LCD1602_EN=0;

}

/*------------------------------------------------

              写入字符串函数

------------------------------------------------*/

 void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s)

 {     

 if (y == 0)

  {     

  LCD_Write_Com(0x80 + x);  //第一行   

  }

 else

  {     

  LCD_Write_Com(0xC0 + x);  //第二行   

  }        

 while (*s) //判断是否检测到结尾符

  {     

   LCD_Write_Data( *s);//显示字符     

   s ++;  //指针加1   

  }

 }

/*------------------------------------------------

              写入字符函数

------------------------------------------------*/

 void LCD_Write_Char(unsigned char x,unsigned char y,unsigned char Data)

{     

 if (y == 0)

  {     

  LCD_Write_Com(0x80 + x);    //第一行    

  }    

 else

  {     

  LCD_Write_Com(0xC0 + x);  //第二行     

  }        

 LCD_Write_Data( Data); //显示字符      

}

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

// 自定义字符数据(CGRAM)

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

void Lcd_Custom_Char(unsigned char row, unsigned char col, unsigned char pos, unsigned char *customValueTable)

{

 unsigned char i = 0;

 for(i=0;i<8;i++){

  LCD_Write_Com(0x40+pos*8+i);//对CGRAM第一个自定义字符操作，若第二个则是0X48，其次类推

  LCD_Write_Data(*(customValueTable+i));//写入显示数据

 }

 if(row==0){

  LCD_Write_Com(0x00+0x80+col);//在第一行显示

  LCD_Write_Data(0x00+pos);//显示自定义字符（0x40对应第一个：0x00，以此类推）

 }else{

  LCD_Write_Com(0x40+0x80+col);//在第二行显示

  LCD_Write_Data(0x00+pos); 

 }

}

 /*------------------------------------------------

                清屏函数

------------------------------------------------*/

 void LCD_Clear(void)

{

 LCD_Write_Com(0x01);

 delay_ms(5);

}

/*------------------------------------------------*/

 void LCD_Init(void)

{

   GPIO_InitTypeDef GPIO_InitStructure;

   

   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC, ENABLE);  //开启GPIOA GPIOC 时钟

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 |GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 |

    GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //输出速度50MHZ

    GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化GPIOA

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 |GPIO_Pin_14 |GPIO_Pin_15;  // LCD1602 RS-RW-EN

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   //推挽输出

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //输出速度50MHZ

    GPIO_Init(GPIOC, &GPIO_InitStructure);   //GPIOC

   LCD_Write_Com(0x38);

   delay_ms(5);  

  LCD_Write_Com(0x38);

   delay_ms(5);  

  LCD_Write_Com(0x38);

   delay_ms(5);  

   LCD_Write_Com(0x08);    /*显示关闭*/

   delay_ms(5);  

   LCD_Write_Com(0x01);    /*显示清屏*/

   delay_ms(5);  

   LCD_Write_Com(0x06);    /*显示光标移动设置*/

  delay_ms(5);

   LCD_Write_Com(0x0C);    /*显示开及光标设置*/

  delay_ms(5);

}

#ifndef __LCD1602_H

#define __LCD1602_H

#include "delay.h"

#include "sys.h"

#define LCD1602_RS PCout(13) //数据命令

#define LCD1602_RW PCout(14) //读写

#define LCD1602_EN PCout(15) //使能

 void LCD_Init(void);

 void LCD_Clear(void);

 void LCD_Write_Com(unsigned char com);

 void LCD_Write_Data(unsigned char Data);

 void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s);

 void LCD_Write_Char(unsigned char x,unsigned char y,unsigned char Data);

 void Lcd_Custom_Char(unsigned char row, unsigned char col, unsigned char pos, unsigned char *customValueTable);

#endif

Timer定时器程序

#include "timer.h"

#include "delay.h"

//通用定时器中断初始化

//这里时钟选择为APB1的2倍，而APB1为36M

//arr：自动重装值。

//psc：时钟预分频数

//这里使用的是定时器2

void TIM2_Init(u16 arr,u16 psc)

{  

 TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

  NVIC_InitTypeDef NVIC_InitStructure;

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

 //初始化定时器2  

 TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值

 TIM_TimeBaseStructure.TIM_Prescaler =psc;  //预分频器   

 TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim

 TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式

 TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位

  

 //中断分组初始化

 NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;  //TIM3中断

 NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  //先占优先级2级

 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  //从优先级0级

 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能

 NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器

 TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);//允许更新中断 ,

  TIM_Cmd(TIM2,ENABLE );  //使能定时器2

}

//这里使用的是定时器3!

void TIM3_Init(u16 arr,u16 psc)

{

  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

 NVIC_InitTypeDef NVIC_InitStructure;

 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能

 TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值  计数到5000为500ms

 TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值  10Khz的计数频率  

 TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim

 TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式

 TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位

 TIM_ITConfig(  //使能或者失能指定的TIM中断

  TIM3, //TIM3

  TIM_IT_Update ,

  ENABLE  //使能

  );

 NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断

 NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  //先占优先级0级

 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;  //从优先级2级

 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能

 NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器

 TIM_Cmd(TIM3, ENABLE);  //使能TIMx外设       

}

#ifndef __TIMER_H

#define __TIMER_H

#include "sys.h"

void TIM2_Init(u16 arr,u16 psc);

void TIM3_Init(u16 arr,u16 psc);

#endif

Gpio引脚初始化程序

#include "gpio.h"

//////////////////////////////////////////////////////////////////////////////////  

//GPIO设置          

//////////////////////////////////////////////////////////////////////////////////     

void KEY_GPIO_Init(void)

{

  GPIO_InitTypeDef  GPIO_InitStructure;

  

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);  //使能PB端口时钟

  

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;     // 端口配置

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;    

  GPIO_Init(GPIOB, &GPIO_InitStructure);   

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;     // 端口配置

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //推挽输出

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //IO口速度为50MHz

  GPIO_Init(GPIOB, &GPIO_InitStructure);   

  GPIO_ResetBits(GPIOB,GPIO_Pin_8); //输出低电平

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;     // 端口配置

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;   

  GPIO_Init(GPIOB, &GPIO_InitStructure); 

}

#ifndef __GPIO_H

#define __GPIO_H  

#include "sys.h"

//////////////////////////////////////////////////////////////////////////////////  

#define PWM_LED PBout(8)

#define SR501 PBin(6)

#define KEY1 PBin(12)

#define KEY2 PBin(13)

#define KEY3 PBin(14)

#define KEY4 PBin(15)

void KEY_GPIO_Init(void);//初始化         

#endif

usart1串口1程序

#include <stm32f10x.h>

#include <stdio.h>

#include "usart1.h"

char Usart1RecBuf[USART1_RXBUFF_SIZE];//串口1接收数据缓存

unsigned int RxCounter = 0;   //串口1收到数据标志位

//////////////////////////////////////////////////////////////////

//加入以下代码,支持printf函数,而不需要选择use MicroLIB   

#if 1

#pragma import(__use_no_semihosting)             

//标准库需要的支持函数                 

struct __FILE

{

 int handle;

};

FILE __stdout;       

//定义_sys_exit()以避免使用半主机模式    

_sys_exit(int x)

{

 x = x;

}

//重定义fputc函数

int fputc(int ch, FILE *f)

{      

 while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   

    USART1->DR = (u8) ch;      

 return ch;

}

#endif

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

描述：Usart1 初始化

   PA9： USART1_TX

   PA10: USART1_RX

参数：none

返回: none

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

void uart1_Init(u32 bound)

{

    //GPIO端口设置

  GPIO_InitTypeDef GPIO_InitStructure;

  USART_InitTypeDef USART_InitStructure;

  NVIC_InitTypeDef NVIC_InitStructure;  

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);

 USART_DeInit(USART1);  

     //USART1_TX   PA.9

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  GPIO_Init(GPIOA, &GPIO_InitStructure);

   

    //USART1_RX   PA.10

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

  GPIO_Init(GPIOA, &GPIO_InitStructure);  

   //Usart1 NVIC 配置

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能

  NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器USART1

  

   //USART 初始化设置

  USART_InitStructure.USART_BaudRate = bound;//一般设置为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(USART1, &USART_InitStructure);

   

  USART_Init(USART1, &USART_InitStructure);     //初始化串口1

  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口1接受中断

  USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);//使能串口1总线空闲中断/

  USART_Cmd(USART1, ENABLE);                    //使能串口1

}

void USART1_IRQHandler(void)                 //串口1中断服务程序

{

  if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断，可以扩展来控制

  {

     if(RxCounter >= USART1_RXBUFF_SIZE) RxCounter = 0;

    Usart1RecBuf[RxCounter++] =USART_ReceiveData(USART1);//接收模块的数据

    }

   USART_ClearITPendingBit(USART1, USART_IT_RXNE);

}

void uart1_SendStr(char*SendBuf)//串口1打印数据

{

 while(*SendBuf)

 {

   while((USART1->SR&0X40)==0);//等待发送完成

    USART1->DR = (u8) *SendBuf;

  SendBuf++;

 }

}

void uart1_send(unsigned char *bufs,unsigned char len)

{

   if(len != 0xFF)

  {

    while (len--)

    {

      while((USART1->SR&0X40)==0);//等待发送完成

      USART1->DR = (u8) *bufs;

      bufs ++;

    }

  }

  else//如果字长等于或超过255，不按用户写入字长发送

    {

        for (; *bufs != 0; bufs++)  //把字符逐个发送出去

     {

      while((USART1->SR&0X40)==0);//等待发送完成

      USART1->DR = (u8) *bufs;

    }

    }

}

#ifndef __usart1_H

#define __usart1_H  

#include "stm32f10x.h"

#define USART1_RXBUFF_SIZE   128

extern unsigned int RxCounter;          //外部声明，其他文件可以调用该变量

extern char Usart1RecBuf[USART1_RXBUFF_SIZE]; //外部声明，其他文件可以调用该变量

void uart1_Init(u32 bound);

void uart1_SendStr(char*SendBuf);

void uart1_send(unsigned char *bufs,unsigned char len);

           

#endif

usart3串口3程序

#include <stdio.h>

#include "usart3.h"

  

char Usart3RecBuf[USART3_RXBUFF_SIZE];//串口3接收数据缓存

unsigned int Rx3Counter = 0;   //串口3收到数据标志位

void USART3_Init(u32 baud)   

 {  

      USART_InitTypeDef USART_InitStructure;  

      NVIC_InitTypeDef NVIC_InitStructure;   

      GPIO_InitTypeDef GPIO_InitStructure;    

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);

      RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);  

  

      // Configure USART3 Rx (PB.11) as input floating    

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;  

      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  

      GPIO_Init(GPIOB, &GPIO_InitStructure);  

  

      // Configure USART3 Tx (PB.10) as alternate function push-pull  

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  

      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  

      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  

      GPIO_Init(GPIOB, &GPIO_InitStructure);  

  

      USART_InitStructure.USART_BaudRate = baud;  

      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;  

  

  

      // Configure USART3   

      USART_Init(USART3, &USART_InitStructure);

      // Enable USART3 Receive interrupts

      USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);  

      // Enable the USART3   

      USART_Cmd(USART3, ENABLE);

  

      //Configure the NVIC Preemption Priority Bits     

      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  

  

      // Enable the USART3 Interrupt   

      NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;   

      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority= 1 ;

      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;        

      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  

      NVIC_Init(&NVIC_InitStructure);       

  }

void USART3_Sned_Char(u8 temp)        

 {  

     USART_SendData(USART3,(u8)temp);      

    while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)==RESET);  

 }

void Uart3_SendStr(char*SendBuf)//串口3打印数据

{

 while(*SendBuf)

 {

   USART3_Sned_Char(*SendBuf);

  SendBuf++;

 }

}

void uart3_send(unsigned char *bufs,unsigned char len)

{

   if(len != 0xFF)

  {

    while (len--)

    {

      USART3_Sned_Char(*bufs);

      bufs ++;

    }

  }

  else//如果字长等于或超过255，不按用户写入字长发送

    {

        for (; *bufs != 0; bufs++)USART3_Sned_Char(*bufs);  //把字符逐个发送出去

    }

}

#ifndef __usart3_H

#define __usart3_H  

#include "stm32f10x.h"

#include "stm32f10x_usart.h"

#define USART3_RXBUFF_SIZE   128

extern unsigned int Rx3Counter;          //外部声明，其他文件可以调用该变量

extern char Usart3RecBuf[USART3_RXBUFF_SIZE]; //外部声明，其他文件可以调用该变量

void USART3_Init(u32 baud);

void USART3_Sned_Char(u8 temp);

void Uart3_SendStr(char*SendBuf);

void uart3_send(unsigned char *bufs,unsigned char len);

#endif