传感器是单片机外围电路中最常见的模块，在搭配了各种形式的传感器电路后，就可以采集到的更多的环境信息。在本章节中，主要介绍呼吸灯、温度传感器、RTC实时时钟以及红外遥控模块的控制使用。
% f. \, S0 x7 e% B' y
1、PWM实现呼吸灯的效果
1.1 PWM脉冲宽度调制
1 ?0 U  x3 \, J7 ?& `PWM是利用单片机的数字输出来对模拟电路进行控制的技术，其应用包含电机控制、通信、开关电源等等。PWM是一种对模拟信号进行数字编码的方法，其本质上还是数字信号，也就是在任意时刻端口输出要么是高电平要么就是低电平，电压或者电流是以一种通或端的重复脉冲序列被加到模拟负载上。因此只要带宽足够，理论上任何的模拟信号都可以使用PWM技术进行数字编码，如下图中所示。


2 l: I" b* Z$ o% k
在STM32F1中除了基本定时器TIM6与TIM7外，其它定时器都具备PWM输出的功能，输出PWM就是对外输出脉宽可调的方波信号，该方波信号的频率由自动重装寄存器ARR决定，占空比由比较寄存器CCR决定，因此改变CCR的值就会使PWM输出信号占空比发生改变（占空比=周期内高电平时间/周期总时间）。PWM最常用的输出模式是PWM1和PWM2，其区别如下表中所示。按照PWM计数器CNT的计数方式，可分为边沿对齐模式；中心对齐模式。

/ V5 m" H# m, X* F9 D& o* z

1.2 PWM输出配置步骤
1.使能定时器及端口时钟，并设置引脚复用映射；
调用函数：RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);//使能 TIM3 时钟；
$ e! t7 [3 E9 X/ U/ N9 O: \TIM3的CH1通道为引脚PA6，在这里需要将这个通道映射到其它IO口上（视硬件电路而定），使用到了GPIO的复用功能，对于TIM3定时器的复用功能如下表中所示。
' t! D: [6 ~8 i+ f7 y2 m' ^8 p% s开启重映射功能需要启动AFIO时钟：RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
调用复用映射功能函数：GPIO_PinRemapConfig(GPIO_FullRemap_TIM3, ENABLE);
配置所映射的管脚模式为复用推挽输出：GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

. T2 K4 E0 P5 y. ]

, L- a+ B  k2 H* g, b3 b2.初始化定时器参数；
" i6 W4 s9 v7 T9 G3 a调用函数：void TIM_TimeBaseInit(TIM_TypeDef*TIMx,TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);
配置细节参见前一章节。
( O( P1 E  ?) w3.初始化PWM输出参数；
* Y  d  u9 F2 {% U- O! ], L; p; Z调用函数：oid TIM_OCxInit(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);
其中TIMx表示的是PWM输出通道可取值为1/2/3/4；结构体TIM_OCInitTypeDef的成员变量为：

1. typedef struct
   
2. {
   
3.         uint16_t TIM_OCMode;                        //比较输出模式
   
4.         uint16_t TIM_OutputState;        //比较输出使能
   
5.         uint16_t TIM_OutputNState;        //比较互补输出使能，高级定时器
   4 u7 h# {" `/ E: T6 V+ `
6.         uint16_t TIM_Pluse;                        //脉冲宽度
   
7.         uint16_t TIM_OCPolarity;                //输出极性
   9 ~4 V. b" U/ e+ X1 `2 J6 e9 @
8.         uint16_t TIM_OCNPolarity;        //互补比较输出极性，高级定时器
   $ k) z. i4 M  v; W9 l9 Y7 g4 c
9.         uint16_t TIM_OCIdleState;        //空闲状态下输出状态，高级定时器
   
10.         uint16_t TIM_OCNIdleState;        //空闲状态下比较输出状态，高级定时器
    * n9 D! g" u* X& l
11. }

复制代码

" Z; M% e9 Q$ s9 fTIM_OCMode：比较输出模式选择，8种模式，常用PWM1、PWM2；
TIM_OutputState：比较输出使能，使能PWM输出到IO口；
TIM_OCPolarity：输出极性，设定输出通道电平的极性，（高/低）；
5 I8 B; w" L3 Q将TIM3的通道CH2配置为PWM2模式，输出极性高低电平，并使能PWM输出的过程可配置为：

1. TIM_OCInitTypeDef TIM_OCInitStructure;
   
2. TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
   
3. TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
   1 s9 g1 }3 ~8 U0 _5 p
4. TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enablel;
   ' h$ }* p5 \& a$ q9 {
5. TIM_OCInit(TIM3, &TIM_OCInitStructure);

复制代码

4.开启定时器；
调用函数：void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState);
' l$ q1 R( D1 k% ~5.修改TIMx_CCRx的值控制占空比；
. Z, G: y% T. l# Z控制占空比需要通过修改TIMx_CCR1的值实现：void TIM_SetComparel(TIM_TypeDef* TIMx, uint32_t Comparel);
6.使能TIMx在CCRx上的预装载寄存器；
调用函数：void TIM_OCxPreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload)
$ L) Y( @: S9 UTIMx为选定的定时器；TIM_OCPreload取值为TIM_OCPreloda_Enable或TIM_OCPreload_Disable。
7.使能TIMx在ARR上的预装载寄存器允许位。
( ?$ V+ E( W- ~+ l0 S调用函数：void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState);
' g: E& K+ [# U9 z: o% N1.3 应用示例-呼吸灯
7 d' r5 C5 n# ?" b! p! M通过TIM3定时器的CH1通道输出一个PWM信号，控制一颗LED由“灭->暗->亮->暗->灭”，不断重复该过程。在项目中需要添加定时器库文件stm32f10x_tim.c以及stm32f10x_tim.h。
( ~$ ^8 I0 T1 [, }" T% Y" M
. e: `; T: F) g( S4 \( s8 R# ~pwm.h
. `" R! K; m# |' J% u  W! C

1. #ifndef _pwm_H
   + g9 _/ W4 C$ }! S, b
2. #define _pwm_H
   " c! r! l( d+ H0 t% h" k
3. 
   
4. #include "system.h"
     d# Q% O2 U8 _4 U* m6 S
5. 
   : B5 `/ r+ L3 ?- n! _4 `
6. void TIM3_CH1_PWM_Init(u16 pre,u16 psc);
   
7. 
   
8. #endif

复制代码

( K% _8 [5 f' T- epwm.c
3 X3 n# n8 y( s/ c4 K4 G

1. #include "pwm.h"
   
2. 
   
3. void TIM3_CH1_PWM_Init(u16 pre,u16 psc)
   
4. {
   
5.         GPIO_InitTypeDef GPIO_InitStructure;
   
6.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
   8 K0 k+ Y: w  }1 \$ H% I2 `: u9 U
7.         TIM_OCInitTypeDef TIM_OCInitStructure;
   % l" K: g4 i$ u" L# @" `( M
8.         
   & y4 d  C: v3 N& |( F' B. w
9.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
   2 K1 d& Y; ?; K
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    
11.         
    
12.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    4 K  w/ x  A! W( B6 v( ^5 f4 J6 a
13.         
    ! G6 [) q7 m! V, n" k
14.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6;
    * A! o0 d5 G" m
15.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
    
16.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
17.         GPIO_Init(GPIOC,&GPIO_InitStructure);
    
18.         
    
19.         GPIO_PinRemapConfig(GPIO_FullRemap_TIM3,ENABLE);                //管脚映射
    
20.         
    
21.         
    1 ]: P& k; k6 C8 @7 H9 F0 v5 V7 `
22.         TIM_TimeBaseInitStructure.TIM_Period=pre;                                        //周期
    - ?0 j' z& J4 U" j2 ]% @) |4 x, [+ d
23.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;
    " A% A. \, r' d3 M( _% W9 Q' w
24.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
25.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up;
    5 n% a2 c1 p- |2 r9 s
26.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);
    
27.         
    , s2 g( D3 B' x& p' o2 V
28.         TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM1;
    ) `' x; h% E. ~1 j
29.         TIM_OCInitStructure.TIM_OCPolarity=TIM_OCPolarity_Low;
    
30.         TIM_OCInitStructure.TIM_OutputState=TIM_OutputState_Enable;
    + Q" V/ M1 z4 \
31.         TIM_OC1Init(TIM3,&TIM_OCInitStructure);
    
32.         
    
33.         TIM_OC1PreloadConfig(TIM3,TIM_OCPreload_Enable);
    , P" i4 M+ @: v* M# N. @+ K" ^
34.         
    
35.         TIM_ARRPreloadConfig(TIM3,ENABLE);
    
36.         
    
37.         TIM_Cmd(TIM3,ENABLE);
    . W6 G8 T/ {( K2 P  i
38.         
    
39. }

复制代码

main.c

1. #include "system.h"
   % K- h) J- E+ O% I8 }
2. #include "led.h"
   
3. #include "SysTick.h"
   % }) D1 I* O! f: i) t0 @
4. #include "time.h"
   ; l4 u0 Z$ w) `8 s( A: l* J0 K% o
5. #include "pwm.h"
   * F( Q0 c$ f; Z
6. 
   
7. 
   4 H9 [4 ^! |" ~
8. int main()
   
9. {
   
10.         u16 i=0;
    
11.         u8 fx=0;
    * O7 ^+ M6 ]' D0 r( H4 E
12.         SysTick_Init(72);
    + d$ E  L; h2 b6 a* |: {, k
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    / A1 }% Q9 T2 i7 O
14.         LED_Init();
    7 \4 P. u+ @5 t' a, y- ?0 u8 @+ J
15.         TIM3_CH1_PWM_Init(500,72-1);
    
16.         
    
17.         while(1)
    ' G- o" f3 y3 t
18.         {
    
19.                 if(fx==0)
      q. {2 n3 ]; L) y9 y8 C2 q( ^
20.                 {
    6 [$ }% g; h  ]4 f* D9 K
21.                         i++;
    
22.                         if(i%300==0)
    
23.                         {
    
24.                                 fx=1;
    
25.                         }
    
26.                 }
    & G0 j6 k) N/ y5 b5 Q2 B; f
27.                 else
    
28.                 {
    " O, I; `4 f  H0 I9 k) L# E
29.                         i--;
    8 Z' X* j( c* U( N, e* Z: L
30.                         if(i==0)
    
31.                         {
    ' F4 J- V# g. M) W+ p- a- h
32.                                 fx=0;
    
33.                         }
    , T* E. N" T( S2 u. @
34.                 }
    ; I# C" j# C) [
35.                 TIM_SetCompare1(TIM3,i);                        //调整占空比
    . W. I7 v5 a; \0 x: ~
36.                 delay_ms(10);        
      T: ~* S4 b1 r! C* X
37.         }
    
38. 
    
39. }
    

复制代码

) [8 z" E/ d  ^- b: t0 F' o2、内部温度传感器
# x# ^% ^/ G% _6 ~- a9 B  q对于传感器采集到的信息一般都是通过电压的变化来表示，而在实际中我们需要直观的看到这个数据信息，那么就需要一个转换过程，可以将模拟信息转换为数字信息。在STM32单片机中，存在着3个ADC（模数转换器）外设，可以独立地使用，将模拟信号转换为数字信号。STM32中的ADC是一个12位逐次逼近型的模拟数学转换器，其具有18个复用通道，可测量16个外部信号源、2个内部信号源。通道的A/D转换可以以单次、连续、扫描或间断模式执行，结果可以以左对齐或右对齐的方式存储在16位数据寄存器中，外设ADC的内部结构如下图中所示：
, j; U+ b7 {2 h- ]) V; b! g6 Z7 [) ]1 Q


3 r+ q5 y* N; Q9 ?- {8 PADC转换的模式有单次转换和连续转换。

1.单次转换模式下，ADC执行一次转换。通过ADC_CR2寄存器的SWSTART位启动，也可以通过外部触发启动。一旦所选定的通道转换完成，转换结果将被保存在ADC_DR寄存器中，ADC停止，直到下一次被启动。
0 |! ~, @/ {, }1 X- j! Y  K2 _2.连续转换模式下，ADC结束一次转换后继续开始下一次的转换。CONT位为1时，通过将ADC_CR2寄存器的SWSTRT位置1或外部触发的方式启动该模式。

; X6 f. l* k& M4 z. F对于ADC的库函数配置版如下所示：
8 l) h3 @/ u& F0 @2 j- ~1.使能端口时钟以及ADC时钟，设置引脚模式为模拟输入；
ADCx_INC0~ADCx_IN5为外部通道，分别对应于芯片的一个引脚，一次需要使能GPIOX以及ADCx时钟（挂载在APB2总线上），调用函数：RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOX|RCC_APB2Periph_ADCx, ENABLE);
- o, j, c4 E3 C然后将对应的引脚设置为模拟输入模式（用于采集电压信号）：
2.设置ADC的分频因子；
* \- z+ }: c* k分频因子要保证ADC的时钟（ADCCLK）小于14MHz，ADC的时钟有72/分频因子计算的出，可调用函数：RCC_ADCCLKConfig(RCC_PCLK2_Divx);
8 M0 t3 J& U$ P7 h3 M1 J5 W3.初始化ADC参数；
初始化ADC时，需要配置ADC的转换模式、触发方式、数据对齐方式等参数，可调用函数：void ADC_Init(ADC_TypeDef* ADCx, ADC_InitTypeDef* ADC_InitStruct);
  Z* l( @  e7 O% i$ b4 X. ZADCx用来选择使用哪一个ADC；结构体ADC_InitTypeDef的成员变量如下：

1. typedef struct
   
2. {
   . A8 a- [$ A- S  L6 ~) d+ d
3.                 uint32_t ADC_Mode;                                                        //工作模式选择
   - d, B+ }+ l) @' K7 ^( @
4.                 FunctionalState ADC_ScanConvMode;                                //扫描模式选择
   
5.                 FunctionalState ADC_ContinuousConvMode;                //转换模式
   * }6 Y3 Q- Q% m0 O4 @" f
6.                 uint32_t ADC_ExternalTrigConv;                                        //触发信号选择
   * i6 p5 w7 z) B  t
7.                 uint32_t ADC_DataAlign;                                                //数据对齐方式
   5 J& k  \- }4 `" P; C
8.                 uint8_t ADC_NbrOfChannel;                                                //采集通道数
   
9. }

复制代码

ADC_Mode：模式选择，独立模式、双重模式；
ADC_ScanConvMode：扫描模式选择，DISABLE（单通道）或ENABLE（多通道）；
ADC_ContinuousConvMode：连续转换模式选择，DISABLE（单次）或ENABLE（连续）；
/ Y7 f) U% q! e4 C* b  z- ]( CADC_ExternalTrigConv：一般默认软件自动触发，不进行配置；
ADC_DataAlign：数据对齐方式，ADC_DataAlign_Right（右对齐）或ADC_DataAlign_Left（左对齐）；
/ [& ], I; C: w3 u4 H4 k. e0 jADC_NbrOfChannel：AD转换通道数目，根据需要选择；

* e: S& D* r6 X" o" V2 M4.使能ADC并开启校准；
- K2 c5 j$ I/ O/ N4 S8 ^5 y! u开启ADC并复位校准后，其才能够正常工作，开启ADC时调用函数：void ADC_Cmd(ADC_TypeDef* ADCx, FunctionalState NewState);
执行复位校准：ADC_ResetCalibration(ADCx);
执行ADC校准：ADC_StartCalibration(ADCx);
校准后需要等待校准结束，可通过校验位进行判断：while(ADC_ResetCalibration(ADCx)); while(ADC_StartCalibration(ADCx));
* ~5 c" I: y5 F* ~- r3 i% w% i5.读取ADC转换值；
- N& E; d" f/ Q6 ]
" e7 N, h: F+ S! w在读取ADC转换值之前还需要设置规则序列中的通道、采样顺序以及采样周期，然后才启动ADC转换；
4 A! }1 Q' D$ O5 Y4 ]
调用函数：void ADC_RegularChannelConfig(ADC_TypeDef* ADCx, uint8_t ADC_Channel, uint8_t Rank, uint8_t ADC_SampleTime);
( G. ^3 O  x1 ~. W, N% C  w开启ADC转换时调用函数（软件触发）：void ADC_SoftwareStartConvCmd(ADC_TypeDef* ADCx, FunctionalState NewState);
读取ADC转换值时调用函数：uint16_t ADC_GetConversionValue(ADC_TypeDef* ADCx);
& r+ ^+ g& _5 O3 L判断ADC的转换是否结束：while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
9 L8 {; {- B2 ^1 J: f7 e  d
2.1 传感器介绍
在STM32F1单片机内部有一个温度传感器，可以被用来测量CPU及周围的温度，它支持的测温范围为-40 oC ~125oC，精度为±1.5 oC。其内部的连接结构如下图中所示：
4 Q# A, d4 p$ Y" v0 j& w& v


在前序内容中已经介绍过了ADC转换的使用，在这里温度传感器的输出信号就是一个电压值的变化，需要通过A/D模数转换成数字信号。对于温度传感器的设置需要考虑到：
" c% A" S' S+ g' r' z' j
  _: `& w9 \: E% b- m9 p( P6 X1.激活ADC内部通道，置ADC_CCR的TSVREFE为1；
2.读取输入端口的电压信号，通过公式将其转换为温度：
T(oC) = ( (V25 - Vsense) / Avg_slope ) + 25;
式中，V25 = Vsense在25 oC时的电压数（1.43V）；Avg_slope=温度与Vsense曲线的平均斜率（4.3mV/ oC）

- `3 h0 D3 R* D% y3 y2.2 配置步骤
对于温度传感器的配置，需要用到ADC相关的库文件（stm32f10x_adc.h和stm32f10x_adc.c），具体步骤如下：
1.初始化ADC参数，开启内部温度控制器，调用函数：ADC_TempSensorVrefintCmd(ENABLE);
2.读取ADC采集到的AD值，将其转换为对应的温度。

2.3 应用示例
通过STM32芯片内部的温度传感器读取温度值，具体的代码如下所示：
% c0 A; t$ L3 r/ S+ z4 Yadc.h
9 E/ e  H: v4 ^1 C3 m+ F

1. #ifndef _adc_temp_H
   
2. #define _adc_temp_H
   0 {# V5 x5 [( B2 \4 F, v4 G
3. 
   
4. #include "system.h"
   % B, {& O# C. e/ L- o$ a
5. void ADC_Temp_Init(void);
   
6. int Get_Temperture(void);
   
7. #endif

复制代码

adc.c

1. #include "adc_temp.h"
   4 ]6 D% R/ ]: E2 e0 y% s
2. #include "SysTick.h"
   
3. #include "usart.h"
   2 }1 {2 f; B% R4 H, V; ^& [' b# l
4. 
   
5. void ADC_Temp_Init(void)
   * E# e5 m; d) P9 {1 C: ?
6. {
   % |6 ]8 B" J9 Z, b) S
7.         ADC_InitTypeDef ADC_InitStructure;
   + Y3 G' U0 m, {7 G  j
8.         
   8 d* `+ b- u" Q- U: N# \
9.         //注意时钟的开启顺序
   & L7 Z8 D9 ^* P( K
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);
    ! L; g) d, e/ C& B3 I5 _
11.         
    
12.         ADC_TempSensorVrefintCmd(ENABLE);                                //开启内部温度传感器通道
    
13.         
    0 s) h# p, ~5 x8 t2 W
14.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    ' `" z7 n8 u1 \( i
15.         
    
16.         ADC_InitStructure.ADC_Mode=ADC_Mode_Independent;        /独立工作模式
    & p9 f& K2 S# w: f
17.         ADC_InitStructure.ADC_ScanConvMode=DISABLE;                //单通道采样
    
18.         ADC_InitStructure.ADC_ContinuousConvMode=DISABLE;        //单次扫描
    
19.         ADC_InitStructure.ADC_ExternalTrigConv=ADC_ExternalTrigConv_None;//不使用外部触发
    . w' E: M4 c. ]
20.         ADC_InitStructure.ADC_DataAlign=ADC_DataAlign_Right;        //数据右对齐方式
    % O; G. Q  r  r$ u; C3 d
21.         ADC_InitStructure.ADC_NbrOfChannel=1;                                 //通道数量
    . F7 e6 k) ~, J. f$ i4 b
22.         ADC_Init(ADC1,&ADC_InitStructure);
    2 ]. y/ r- C6 U$ W4 C, H
23.         
    / }: E& B% A# Z  N  m" h3 i, B+ {
24.         ADC_Cmd(ADC1,ENABLE);                                                        //使能ADC
    
25.         
    
26.         ADC_ResetCalibration(ADC1);                                                        //复位校准
    
27.         while(ADC_GetResetCalibrationStatus(ADC1));                                
    
28.         
    1 t3 _1 M9 u8 W/ u+ l4 n* S
29.         ADC_StartCalibration(ADC1);                                                        //开启校准
    
30.         while(ADC_GetCalibrationStatus(ADC1));                                       
    
31.         
    1 i3 O! v- H4 x, x- ]
32.         ADC_SoftwareStartConvCmd(ADC1, ENABLE);                        //软件启动ADC
    , p! [$ r) x  F2 h
33. }
    # }7 X3 s1 d: ~9 i2 q
34. u16 Get_Temp_Value(u8 ch,u8 times)                                                        //获取ADC通道采集回来的数据
    ) o. _; b: a0 y1 v' a, R* `
35. {
    
36.         u8 t;
    
37.         u32 temp_val=0;
    
38.         ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5);
    
39.         for(t=0;t<times;t++)
    
40.         {
    
41.                 ADC_SoftwareStartConvCmd(ADC1, ENABLE);                //软件启动ADC
    
42.                 while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
    
43.                 temp_val+=ADC_GetConversionValue(ADC1);
    
44.                 delay_ms(5);
    
45.         }
    
46.         return temp_val/times;
    ! G2 e: ?5 H4 B. m! J8 t) z: Z
47. }
    
48. int Get_Temperture(void)
    
49. {
    
50.         u16 temp;
    
51.         double tempreture;
    8 V! z" l/ ]% W9 W; a
52.         int T;
    
53.         temp=Get_Temp_Value(ADC_Channel_16,10);
    8 }) m' o$ ]" Y" b, U
54.         printf("%d\r\n",temp);
    * |, D+ E% T7 [# x& _
55.         tempreture=(float)temp*(3.3/4096);
    
56.         tempreture=(1.43-tempreture)/0.0043+25;
    ( b7 H' M: n2 D9 z! w9 ?! ~* |$ f
57.         T=tempreture*100;
    1 G7 p4 G' @& O6 S  p& Y7 o! G% U% H
58.         printf("%d\r\n",T);
    
59.         return T;
    # Z6 G) g1 \3 g/ w3 ?6 r+ I
60. }
    

复制代码

# h4 i& h. a% I4 s! nmain.c
* ?% ^6 r7 U/ T

1. #include "system.h"
   ( X$ s* R" B7 q* T
2. #include "led.h"
   
3. #include "SysTick.h"
   
4. #include "usart.h"
   9 |; k4 r  S2 D) w+ ?9 u( ~4 Q$ d
5. #include "adc_temp.h"
   $ z  S4 \1 R' i* {5 D" O
6. 
   ' z* [+ ~0 T0 j, s) P3 c
7. int main()
   
8. {
   % Z) U* D# W* c: N$ J6 Y9 {; {
9.         u8 i=0;
   
10.         int tempreture;
    
11.         
    / k' P: S' V2 n; o  ~/ y3 V: ~
12.         SysTick_Init(72);
    0 i) b0 U: O. H" h& A8 j
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                //中断优先级分组
    : q3 G, Q, B$ {; Z) ^2 h
14.         LED_Init();
    
15.         USART1_Init(9600);
    
16.         ADC_Temp_Init();
    / S+ x( d! b% `
17. 
    # E4 s( W4 ]) e: F, C  g( M: o
18.         while(1)
    
19.         {
    
20.                 i++;
    % Q+ Y; n' {+ O; s! s/ Q' F
21.                 if(i%20==0)
    
22.                 {
    % f) Y. G; g+ w
23.                         led1=!led1;
    5 {3 X# \' z+ c& O) o
24.                 }
    
25.                
    ' h! g+ ]9 J7 t6 L& Z; @
26.                 if(i%50==0)
    , ~! ^3 p5 t: l% f/ d: v. k
27.                 {
    " F4 v! v! M( T! c# T9 m
28.                         tempreture=Get_Temperture();
    7 a% [: m* g& L2 G% M
29.                         if(tempreture<0)
    & t% [+ a0 O3 n! k
30.                         {        
    7 g" v9 {0 u! d& E% V- N0 q' z
31.                                 tempreture=-tempreture;
    7 h5 ~' Y! G" @/ h! a. x
32.                                 printf("节点温度为：-%.2f C\r\n",(float) tempreture/100-1);
    
33.                         }
    
34.                         else
    
35.                         {
    
36.                                 printf("节点温度为：+%.2f C\r\n",(float) tempreture/100-1);                        
    $ i. F4 z# Y6 V0 T! K4 L
37. }
    6 y! `: I# i5 I0 _0 z/ ^
38.                 }
    6 G. h: u  n0 [9 D. ], z
39.                 delay_ms(10);        
    1 n$ o5 S* q$ x" H# O3 q: J2 l
40.         
    
41.         }
    1 H6 E) d  o4 x8 a2 `; A
42. }

复制代码

, Y6 q4 d8 g7 F; S- f3、RTC实时时钟
3.1 传感器介绍
; h. u. ~& z- M在STM32中RTC（实时时钟）是一个独立的定时器，其具有一组连续计数的计数器，可提供时钟日历的功能。RTC模块拥有一个后备电源—纽扣电池，因此当主控掉电时，只要纽扣电池有电，RTC就会正常的工作。RTC是一个32位的计数器，采取向上计数模式，其时钟源来自于高速外部时钟的128分频、低速内部时钟LSI以及外部时钟LSE三种。在使用HSE分频时钟或LSI时，主电源掉电时，时钟会受到影响，导致RTC无法正常工作。因此一般情况下，RTC使用LSE时钟。RTC的内部结构图如下所示：
! ?" _& j# {' a; o* x- }
/ A; P+ O  s" _0 l

3.2 配置步骤
对于RTC的配置，需要用到RTC相关的库文件（stm32f10x_rtc.h和stm32f10x_rtc.c），具体步骤如下：
4 d! N4 ]7 w6 m, m
1.使能电源时钟和后备域时钟，开启RTC后备寄存器写访问；
9 t7 c0 ?' |/ M, K4 f/ r9 E" c调用库函数：RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); //使能电源时钟 RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE); //使能后备域时钟 PWR_BackupAccessCmd(ENALE); //使能后备寄存

  d% O7 [! ]8 U7 l. W2.复位备份区域，开启LSE时钟；
在开启后备寄存器写访问后，首先要对该区域进行复位操作，之后使能LSE时钟，调用函数：BKP_DeInit(); //复位备份区域 RCC_LSEConfig(RCC_LSE_ON); //开启LSE时钟
. ^% j) x$ P! ~, ^% b9 L! p
3.使能RTC时钟；
选择LSE作为RTC时钟源，之后使能RTC时钟，调用函数：RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); RCC_RTCCLKCmd(ENABLE);
6 o' W% i9 ], u7 j5 Z
4.设置RTC分频系数，配置RTC参数；
首先要打开RTC允许配置位：RTC_EnterConfigMode();
设置RTC时钟分频系数：void RTC_SetPrescaler(uint32_t PrescalerValue);
设置秒中断允许：void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState);
: E, o* \( B9 D7 a6 h5 D1 g( J% h设置RTC计数值：void RTC_Setounter(uint32_t CounterValue);
. K, E. I& F5 V4 {
# e% a5 n) Z2 U8 Q, Q0 V5.更新配置，设置RTC中断分组；
8 z3 f* [: ^/ [调用配置更新函数：RTC_ExitConfigMode();
; O8 Q& \. V5 o' q8 R在备份区域写用户数据：void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data);
读取备份区域内容：uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR)；
) s4 \9 L6 D7 r* n' d. Y$ a配置中断分组：NVIC_Init

6.编写RTC中断服务函数。
在STM32中RTC中断函数为：RTC_IRQHandler;
读取RTC状态标志位：FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG);
清除RTC秒中断标志：RTC_ClearITPendingBit(RTC_IT_SEC);
8 u2 z. i- Z- u  q
3.3 应用示例
设置STM32的RTC时间初始值，进行计时，详细的配置代码如下：
rtc.h
5 ~0 K9 b) O' \7 r3 C& z0 ^

1. #ifndef _rtc_H
   
2. #define _rtc_H
   
3. 
   
4. #include "system.h"
   
5. 
   " ^% q: i* m; f3 t6 C) S
6. typedef struct{
   
7.         u8 hour;
     J9 F1 [! z+ q( L8 {8 S: v
8.         u8 min;
   
9.         u8 sec;
   
10. }_calendar;
    ' x# O+ T' n) T% E3 B2 Z
11. 
    * B) g9 O' J* u0 O/ O
12. extern _calendar calendar;
    
13. void RTC_Get(void);
    
14. u8 RTC_Init(void);
    8 z" |' D4 ?; ]/ U! ^9 ~# j
15. 
    
16. #endif

复制代码

; [- `: Y1 s; G  P" r+ Crtc.c

1. #include "rtc.h"
   9 e( c3 B& k) ^' s7 x, o; d+ f) V
2. #include "SysTick.h"
   7 l: z* q0 X; |2 \" e
3. #include "usart.h"
   * F! h9 z4 l% w; f. B2 f" t3 B
4. 
   
5. 
   5 R2 p/ E' c8 R# x6 ^$ M- T
6. _calendar calendar;
   0 g6 d$ |- g0 C8 \3 Z- W
7. 
   
8. void RTC_NVIC_Config()
   6 [0 \5 x4 B. Q7 ^, R
9. {
   - m9 p. [" k' l9 `! \
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11.         
    5 ?& I  B$ Y4 l% L6 X
12.         NVIC_InitStructure.NVIC_IRQChannel=RTC_IRQn;
    
13.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    4 D, S9 v: c% p& |5 \
14.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=3;
    8 k% ~# R" Z- V: s& ]
15.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
16.         NVIC_Init(&NVIC_InitStructure);
    
17. }
    
18. void RTC_Get(void)
    ) F) p4 x3 a' J. y/ a3 X
19. {
    7 J  P7 r+ ]8 v/ S
20.         u32 time=0;
    
21.         time=RTC_GetCounter();
    ( x! q5 f1 q9 b4 c7 B( Q8 r* n3 a
22.         calendar.hour=time/3600;
    
23.         calendar.min=time%3600/60;
    1 [; B# s. U, ]# O  f
24.         calendar.sec=time%60;
    
25. }
    8 t/ y0 S- u9 ^% `: c9 X  y: M$ H9 a
26. u8 RTC_Init(void)
    0 M. d" i0 [9 ], g; R4 m/ H
27. {
    $ C1 O7 |6 a* _  |' b  Q8 m
28.         u8 temp=0;
    ' `) x: B7 U2 O& }; u
29.         
    
30.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);//使能电源和后备域时钟
    * Z- e+ k4 R. l1 s7 p1 d' v5 ?
31.         PWR_BackupAccessCmd(ENABLE);//开启RTC后备寄存器访问
    ( A: Q0 S+ e' c+ d7 j& j1 L
32.         
    / @# f% G% j* F" l  z, ^- v
33.         if(BKP_ReadBackupRegister(BKP_DR1)!=0xA0A0)//第一次进入RTC
    . e2 p& s$ |0 _/ D9 S, R& P
34.         {
    2 `6 H: S  d5 G1 I) D3 o5 W
35.                 BKP_DeInit();/后备域寄存器初始化
    ' U( n$ Q5 w0 h! P1 s. Y0 e+ o- m
36.                 RCC_LSEConfig(RCC_LSE_ON);//开启LSE外部晶振
    6 E, E& P7 C7 D4 p3 Z
37.                 while(RCC_GetFlagStatus(RCC_FLAG_LSERDY)==RESET&&temp<250)//2.5秒为开启即退出
    7 ]8 [# p/ k/ ~- P0 ^5 i% B
38.                 {
    7 p& u. i/ B/ N3 V
39.                         temp++;
    
40.                         delay_ms(10);
    8 }2 n" N; {9 _" u4 ?
41.                 }
    
42.                 if(temp>=250)/初始化失败，晶振不稳定
    # ]' F5 m/ R% N
43.                 {
    % L7 ^4 o' C8 Q1 C" c$ O9 g" a! P6 n
44.                         return 1;
    
45.                 }
    
46.                 RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    $ V) V% r& R- e9 C8 Z
47.                 RCC_RTCCLKCmd(ENABLE);
    
48.                 RTC_WaitForLastTask();
    , L3 W: x$ u! p3 N3 W! A+ z
49.                 RTC_WaitForSynchro();
    
50.                 RTC_ITConfig(RTC_IT_SEC,ENABLE);
    
51.                 RTC_WaitForLastTask();
    
52.                 RTC_EnterConfigMode();
    
53.                 RTC_SetPrescaler(32767);
    
54.                 RTC_WaitForLastTask();
    # Z6 B& M0 a0 u
55.                 RTC_SetCounter(0x11DB4);
    
56.                 RTC_ExitConfigMode();
    
57.                
    
58.                 BKP_WriteBackupRegister(BKP_DR1,0xA0A);
    
59.         }
    * S9 v7 P/ |) P4 v, N
60.         else
    
61.         {
    
62.                
    
63.                 RTC_WaitForSynchro();
    " P* a" r. U: U/ |5 j* V
64.                 RTC_ITConfig(RTC_IT_SEC,ENABLE);
    1 e) g2 ?- M& }- }: C. Z5 r1 q; N8 {
65.                 RTC_WaitForLastTask();
    
66.         }
    ( K. Y3 s* H% q: ]
67.         RTC_NVIC_Config();
    
68.         RTC_Get();
    7 x3 C9 @7 l/ F1 C7 X' M" @" p
69.         return 0;
    : m+ X1 y7 I- U1 c; g2 F3 a+ C
70. }
    # _. {5 n8 v$ V7 z# ?
71. void RTC_IRQHandler(void)
    & S/ P5 e) V4 V8 ]* z
72. {
    
73.         if(RTC_GetITStatus(RTC_IT_SEC)!=RESET)
    1 L% F% [3 ^  }- o: E
74.         {
    
75.                 RTC_Get();
    2 R. F) T$ J2 T9 E8 q/ `% F
76.                 printf("RTC Time:%d:%d:%d\t\n",calendar.hour,calendar.min,calendar.sec);
    4 o7 s. d7 o" S/ C
77.         }
    - D% D1 b' E& r7 i1 Z# h
78.         RTC_ClearITPendingBit(RTC_IT_SEC);
    
79. }

复制代码

main.c
# C8 `2 g5 i6 i( ~* C1 H3 F( a

1. #include "system.h"
   
2. #include "led.h"
   % K1 ]2 T: d1 s& R
3. #include "SysTick.h"
   ! v8 F5 B5 h% m2 x3 b
4. #include "usart.h"
   ) D# p" o* |, ]- T
5. #include "rtc.h"
   
6. 
   
7. int main()
   ; _7 Z, G9 V* h* O4 b/ N! x9 b# D
8. {
   
9.         u8 i=0;
   : n. T" Q( ?& t% Y/ U1 |- G: e, N6 S
10.         
    
11.         SysTick_Init(72);
    " G( Z: u( H0 ~' m8 z
12.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//ÖжÏÓÅÏȼ¶·Ö×é
    
13.         LED_Init();
    ' `- |( j" a2 ]6 B/ u1 G& j
14.         USART1_Init(9600);
    
15.           RTC_Init();
    
16.         while(1)
    ( S+ ~  G! Q5 d9 {5 |" A4 Y2 [
17.         {
    
18.                 i++;
    8 d, |8 c  z) v) f- [
19.                 if(i%20==0)
    
20.                 {
    ; Y6 t' p# d9 T3 l
21.                         led1=!led1;
    
22.                 }
    ! d& A3 ]- I; Q; D! `/ @6 Q, N8 L
23.                 delay_ms(10);
    
24.         }
    
25. }
    

复制代码

+ Q. K; Y- ^1 V, T$ N  E$ Q! V, i( L4、红外遥控
4.1 传感器介绍
% R6 e0 v; x0 R' b# Y$ ]2 Y" R" |4 _红外遥控是一种利用波长为0.76~1.5μm之间的近红外线来传输控制信号的方法，它是一种无线控制技术，具备较强的抗干扰性、功耗低、成本低以及容易实现的特点。由于红外线无法穿透障碍物，因此对于同类产品的红外线遥控器接收器可以有相同的遥控频率或编码，大大方便了控制系统设计并且易于调试。红外遥控通信系统由红外线发射装置以及红外线接收设备两大部分组成。
# _$ S1 B- A( ]9 Q# l! y1 L
4.2 配置步骤
( i" f4 {- N+ g6 V# ~) z根据红外遥控通信控制系统的组成，对于红外遥控的配置分为如下两部分：
1.红外发射装置
红外发射装置比较常见的就是遥控器，由键盘电路、红外编码电路、电源电路以及红外发射电路组成。目前被大量使用的遥控器发出的红外线波长在940nm上下，可普通的发光二极管的形状相同，但是红外发光二极管发出光属于不可见光。典型的红外遥控器与红外二极管如下图中所示.


6 W% |+ t! j- H! c$ j
/ Q  I7 n! {) h( _! R: [$ ?, D+ a通常红外遥控为了提高抗干扰性和降低电源消耗，采用了载波的方式传输二进制编码，载波的频率一般为38kHZ由发射端的晶振频率所决定。常用的二进制编码脉冲为NEC Protocol的PWM码和Philips RC-5 Protocol的PWM码。当采用NEC码时，一个脉冲对应560us的连续载波，传输1需要2.25ms（560us的脉冲+1680us的低电平信号），传输0需要1.125ms（560us的脉冲+560us的低电平信号）。NEC遥控指令码的数据格式分为引导码、地址码、地址反码、控制码以及控制反码。引导码是一个9ms的低电平和一个4.5ms的高电平组成；地址码、地址反码、控制码以及控制反码为8位数据格式，按照低位在前、高位在后的顺序发送。NEC中的连发码是有9ms低电平+2.5ms高电平+0.56ms低电平+97.94高电平组成。在按下遥控器的一个按键一帧数据发送后，按键没有松开则发送连发码，通过统计连发码的次数可以计算出按键按下的长短或次数。
" o( ^4 Q* v1 b6 m8 c7 P3 J% f6 |& n
. t: Z3 p: ]: Q% d# d2.红外接收设备
, z, V. p* J1 N+ A红外接收设备由红外接收电路、红外解码、电源以及应用电路组成。红外接收器的作用是将遥控器发射来的红外光信号转换成电信号，再经过放大、限幅、检波以及整形的步骤形成遥控指令脉冲信号，输送至单片机。一个红外接收头的实物如下图所示：
2 x; C8 T" A  t! S, D9 H$ s& y
) v- R; ?! V1 x$ l/ i* r
% L) D9 `* Q  j2 w% i) P7 a
% |  @& y' W& c5 G$ ?6 B红外接收头在没有受到红外脉冲的时候为高电平，收到脉冲时为低电平，因此可以通过外部中断的下降沿触发中断模式在中断服务函数中计算高电平的时间来判断接收到的二进制码时0或1。在STM32的红外遥控接收端的软件程序框架大致如下：
/ S$ Z5 D3 a% ~6 y* b! y) `
1.使能IO口以及AFIO时钟，复用引脚IO到外部中断线上，初始化中断系统；
5 c0 b! ~/ O/ [- ^' G5 X2.编写中断服务函数，包含红外解码部分；
" x7 S: K% U1 p8 j' U0 E3.编写main函数。

4.3 应用示例
& s1 A- J  U3 O6 _2 M0 `3 ^利用STM32的中断功能解码红外接收端受到的遥控指令，详细的代码如下：
' K9 @: z9 |$ U  C1 V5 z- P) X, Lhw.h

1. #ifndef _hw_H
   + R2 q3 C& s( q6 Z6 @+ b
2. #define _hw_H
   1 D7 G) W: L7 J1 o! t$ \. q( G1 Q$ B% Z
3. 
   
4. #include "system.h"
   ' {9 r  f4 e' |7 l# C4 c
5. 
   
6. void HW_Init(void);
   & i) J! Y4 E1 }& s8 q. Q
7. u8 hw_getHigh(void);
   
8. 
   
9. extern u32 hw_jsm;
   
10. extern u8 hw_jsbz;
    ) F; P1 V+ ]% O: N2 ]6 K3 P! x8 F
11. 
    : H$ @* d3 _  X% o/ P6 B! @
12. #endif

复制代码

hw.c
/ K+ R7 \2 o" L- @, g1 f
( q# S  ]: n1 J+ U, b! u1 q

1. #include "hw.h"
   ; X$ L# F' }3 G2 A% a, ^$ W  H
2. #include "SysTick.h"
   ; x! m5 r7 F. k: r2 B
3. 
   
4. u32 hw_jsm;                         //存储接收码
   
5. u8 hw_jsbz;                         //接收标志
   
6. 
   
7. 
   ) d6 M3 }3 x5 ~7 i/ \% J1 n
8. void HW_Init(void)
   2 O' \' Y/ |0 a4 F
9. {
   # M# Y7 A* n' r& u% k! \
10.         GPIO_InitTypeDef GPIO_InitStructure;
    
11.         EXTI_InitTypeDef EXTI_InitStructure;
    ; Z: ~3 z0 ^! I6 V( `% @9 p
12.         NVIC_InitTypeDef NVIC_InitStructure;
    
13.         
    
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG|RCC_APB2Periph_AFIO,ENABLE);
    
15.         
    
16.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_15;
    
17.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
    ( D3 w+ v, k; [' }( p) I* c6 ~
18.         GPIO_Init(GPIOG,&GPIO_InitStructure);
    2 T! }: {  I) \4 u  I
19.         
    * r9 t" Z! ]3 U! Z  ~& R7 O
20.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOG,GPIO_PinSource15);
    ( _/ }! E1 O9 h, D4 e
21.         EXTI_ClearITPendingBit(EXTI_Line15);
    6 H; W. A/ s( l, v5 Z6 T; X' `' P
22.         
    
23.         EXTI_InitStructure.EXTI_Line=EXTI_Line15;
    ) `" R2 d# Q/ F
24.         EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
    ) ^( E# ~  Z5 [
25.         EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;//ϽµÑØ´¥·¢
    
26.         EXTI_InitStructure.EXTI_LineCmd=ENABLE;
    
27.         EXTI_Init(&EXTI_InitStructure);
    
28.         
    
29.         NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQn;
    ! _- q5 m% H) m8 _% g  c# F
30.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
    - H7 }* d+ S8 I5 P* \7 c% b  }1 i" q
31.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
    
32.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
33.         NVIC_Init(&NVIC_InitStructure);
    7 C+ w4 [  X4 ~  V, z/ j
34. 
    
35. }
    
36. u8 hw_getHigh()                //得到高电平持续的时间
    
37. {
    
38.         u8 t=0;
    
39.         while(GPIO_ReadInputDataBit(GPIOG,GPIO_Pin_15)==1)
    " K2 r4 y- M- V' V) W8 E" m# ]
40.         {
    . i6 E$ z! r9 Q2 L/ U
41.                 t++;
    
42.                 delay_us(20);
    3 T( ~/ z0 `* R& B) I/ _
43.                 if(t>=250)
    " |. g, q( o# o- s$ D3 S' c
44.                         return t;
    ; a* g, f- H) m7 P" f$ |, x3 p8 A/ O
45.         }
    - K. k6 s+ ]  G3 ]7 b4 u
46.         return t;
    
47. }
    
48. void EXTI15_10_IRQHandler(void)
    
49. {
    
50.         u8 Tim=0,Ok=0,Data,Num=0;
    ; g4 h$ c7 ?- P0 c
51.         while(1)
    6 c$ O' m; u% G& _7 Q! K9 @' d2 V: x
52.         {
    4 g  ~9 K; M$ W, t" R+ y
53.                 if(GPIO_ReadInputDataBit(GPIOG,GPIO_Pin_15)==1)
    
54.                 {
    
55.                         
    
56.                         Tim=hw_getHigh();               
    
57.                         
    
58.                         if(Tim>=250)                                //无效信号
    ' s. I. y6 Z1 A  [% H8 e$ ]+ d
59.                                 break;
    
60.                         if(Tim>=200&&Tim<250)
    , T+ ]0 B  i- ?- s: Q7 g
61.                         {
      v- T7 q; v! N  y
62.                                 Ok=1;                                //起始信号
    . X0 n8 ~; W. F- V9 ~0 _+ u1 v* h' K
63.                         }
    
64.                         else if(Tim>=60&&Tim<90)
    1 `, r9 h) D9 k# w) W6 C- t
65.                         {
    0 Q9 X) E0 i* v
66.                                 Data=1;                                /数据1
    % v5 X  v5 _( z. C3 ~2 M. i  m
67.                         }
    + T5 A5 o5 @; O( ?
68.                         else if(Tim>=10&&Tim<50)
    
69.                         {
    
70.                                 Data=0;                                //数据0
    * ^( G5 d" B5 k3 N5 i# I% j7 y
71.                         }
    . T3 s- A. x+ y% U' i' a
72.                         if(Ok==1)
    ( t2 ^5 i) B! C# [9 ]) S& g
73.                         {
    
74.                                 hw_jsm<<=1;
    ) I3 {! F7 }: _: Y) o* L5 I
75.                                 hw_jsm+=Data;
    2 G) I6 W) d" x$ l
76.                                 if(Num>=32)
    
77.                                 {
    
78.                                         hw_jsbz=1;
    
79.                                         break;
    
80.                                 }
    
81.                         }
    # d; C: {  D/ n# G7 `6 x
82.                         Num++;
    4 k8 i. |, G" T7 o
83.                 }
    & {8 K1 L! A! v: H  O- h
84.         }
    
85.         EXTI_ClearITPendingBit(EXTI_Line15);
    ) L3 p0 X" f7 i4 }* F% o5 g
86. }
    5 o& D; A0 Q" f8 D* ]: C: ]8 x5 n8 f

复制代码

main.c
, `: c6 b& {6 v6 }7 [0 p& _& M
( E: ~. W4 P0 s- a5 x7 X

1. #include "system.h"
   
2. #include "led.h"
   
3. #include "SysTick.h"
   - i/ X( w' ^$ r6 `
4. #include "usart.h"
   1 b! Q1 w1 v; Z3 i. _+ V3 F4 r
5. #include "hw.h"
   
6. 
   
7. int main()
   / S4 ^6 G# P% Y' L' w
8. {
   % A/ E' b( x  f. q# s5 _8 N; f3 t+ D
9.         u8 i=0;
   " o& N. N) N( B/ d5 D- \; \, X
10.         
    
11.         SysTick_Init(72);
    
12.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    . x4 W0 U0 a) q7 l9 a
13.         LED_Init();
    
14.         USART1_Init(9600);
    
15.         HW_Init();
    
16.         while(1)
    
17.         {
    
18.                 if(hw_jsbz==1)
    
19.                 {
    
20.                         hw_jsbz=0;
    
21.                         printf("红外接收码 %0.8X\r\n", hw_jsm);
    
22.                         hw_jsm=0;
      w3 t" o+ |! t4 M& X3 W) r
23.                 }
    
24.                 i++;
    
25.                 if(i%20==0)
    + N3 @* k* K% e0 z+ E  ?& A
26.                 {
    & J4 Z0 p! M: j
27.                         led1=!led1;
    
28.                 }
    # C* s* t- Y( M4 ?
29.                 delay_ms(10);
    
30.         }
    " S1 S' M" b* f% X& ]: B
31. }

复制代码

' W8 N+ R% b0 F. ?
/ b4 u7 y$ ^( X0 ^" u: [4 [