红外接收头很常见，具体就不细说了，这里记录重点：

NEC的特征
- J9 @5 H9 d6 T1：使用38 kHz 载波频率
* J3 O- w8 X8 H& P& y6 p2：引导码间隔是9 ms + 4.5 ms
3：使用16 位客户代码
4：使用8 位数据代码和8 位取反的数据代码
; U& B; W7 o  K
) j2 |8 P# c( g5 d; ?当发射器按键按下后，即有遥控码发出，所按的键不同遥控编码也不同。这种遥控码具有以下特征：采用脉宽调制的串行码，以脉宽为0.565ms、间隔0.56ms、周期为1.125ms的组合表示二进制的“0”；以脉宽为0.565ms、间隔1.685ms、周期为2.25ms的组合表示二进制的“1”，其波形如图所示。
+ G' W% H! [8 p1 V1 F, r) W* {. S. |
1 \' f3 ?) W9 z' }" Z
" N# w5 p+ O8 q, U4 q5 W& G+ ~
) G) h4 n" |6 r& r
8 E2 X# [# b2 Q
- @4 ]. z. T4 E& }0 n4 Y
这里我采用同一个定时器TIM3的两个通道分别用来做红外的接收和发送，接收用通道3的输入捕获，发送用通道4的输出比较，程序采用分时复用的方式完成收发一体的实验效果。默认处于接收状态，在按键触发时切换成发射状态发送红外数据，发送完成后再次默认切换成接收。

上接收部分的代码：

) E, W3 y6 s4 u1 [& V" r2 r

1. #define NEC_HEAD                (u16)(4500)
   * p7 G, |% g( \* S% Q; `6 y2 p1 i0 G  E3 n
2. #define NEC_ZERO                 (u16)(560)
   : E7 f: j0 y1 D& D; ^: i
3. #define NEC_ONE                        (u16)(1680)
   7 Z+ P8 q1 p( |& w$ K
4. #define NEC_CONTINUE         (u16)(2500)
   
5. 
   0 L) L4 x! N/ ?. T& A1 N9 y
6. #define NEC_HEAD_MIN (u16)(NEC_HEAD*0.8f)
   . O, c$ g9 Y# v$ S4 j
7. #define NEC_HEAD_MAX (u16)(NEC_HEAD*1.2f)
     H4 ~) ^8 D6 F" }. F- Z+ E, d
8. 
   
9. #define NEC_ZERO_MIN (u16)(NEC_ZERO*0.8f)
   5 {4 [$ Z0 g1 G8 |$ G
10. #define NEC_ZERO_MAX (u16)(NEC_ZERO*1.2f)
    " N6 ]5 x7 m# D" O4 J
11. 
    
12. #define NEC_ONE_MIN (u16)(NEC_ONE*0.8f)
    
13. #define NEC_ONE_MAX (u16)(NEC_ONE*1.2f)
    
14. 
    
15. #define NEC_CONTINUE_MIN (u16)(NEC_CONTINUE*0.8f)
    ( \- g' T& b! M1 f7 N
16. #define NEC_CONTINUE_MAX (u16)(NEC_CONTINUE*1.2f)
    8 P5 S* p7 c, s0 v$ l0 n
17. 
    
18. 
    
19. //红外遥控接收初始化
    ; t5 j. S( M7 P; L5 a& G7 n6 R
20. void NEC_RX_Configuration(void)
    
21. {
    
22.     GPIO_InitTypeDef GPIO_InitStructure;
    
23.     NVIC_InitTypeDef NVIC_InitStructure;
    : ~/ T/ N' F& E& x
24.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    5 F4 ~7 V, Y! Z, e6 f8 M+ o: g
25.     TIM_ICInitTypeDef  TIM_ICInitStructure;//输入捕获
    5 M: k: S# S% g9 k, D+ s+ t- i7 O  r
26.         
    
27.     RCC_APB2PeriphClockCmd(NEC_RX_RCC|NEC_TX_RCC,ENABLE); //使能PORT时钟
    
28.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);         //TIM3 时钟使能
    ( @7 U0 R5 {% I% p9 o" w; F
29.         
    
30.     GPIO_InitStructure.GPIO_Pin = NEC_RX_PIN;                        
    0 |0 R( K5 _  a
31.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;                  // 上拉输入
    4 C, A3 R, E. o  y* q7 p; w3 ]* q
32.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
33.     GPIO_Init(NEC_RX_PORT, &GPIO_InitStructure);
    
34. 
    , `4 m# Q; E  K- e+ }3 F
35.     GPIO_InitStructure.GPIO_Pin = NEC_TX_PIN;                        
    
36.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出
    ' b" ~6 b4 |1 A1 e6 b
37.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
38.     GPIO_Init(NEC_TX_PORT, &GPIO_InitStructure);
    
39. 
    " F! Z4 [4 M: C% Y6 L' H
40.     TIM_TimeBaseStructure.TIM_Period = 10000; //设定计数器自动重装值 最大10ms溢出
    0 ~+ r8 P/ F  @
41.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //预分频器,1M的计数频率,1us加1.
    
42.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
    2 h# w; O8 D6 @: g; R3 t
43.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    ' T' Z3 W# u4 O4 V8 w3 d
44.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx
    
45. 
    
46.     TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;  // 选择输入端 IC3映射到TI3上
    . g4 m# G  \' K; y- p" @
47.     TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
    
48.     TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
    
49.     TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
    0 U7 Y0 m* w, }5 F% H& J
50.     TIM_ICInitStructure.TIM_ICFilter = 0x03;//IC4F=0011 配置输入滤波器 8个定时器时钟周期滤波
    2 d: }! o) x. _- w1 B8 T6 \* X
51.     TIM_ICInit(TIM3, &TIM_ICInitStructure);//初始化定时器输入捕获通道
    
52. 
    
53.     NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
    * i3 B* q. r# o5 F+ z. E0 q2 u
54.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级2级
    
55.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  //从优先级
    
56.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
    1 B! Q+ p6 ~4 j5 V
57.     NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    ( D  C$ r+ j6 j
58. 
    
59.     TIM_ITConfig( TIM3,TIM_IT_Update|TIM_IT_CC3,ENABLE);//允许更新中断 ,允许CC3IE捕获中断
    ' A4 a5 @: A( ^3 Y4 g5 Y( ]8 t% I
60.         
    
61.         TIM_ARRPreloadConfig(TIM3,ENABLE);        //重装载
    
62. 
    
63.     TIM_Cmd(TIM3,ENABLE );         //使能定时器3
    
64. }
    
65. 
    & Q2 [: v" E  b; b9 [: P
66. //遥控器接收状态
    7 J' X) Z7 N, Q* E# e' D- R* V) P
67. //[7]:收到了引导码标志
    # e' |7 k- {- O* A, M3 v* h# i
68. //[6]:得到了一个按键的所有信息
    
69. //[5]:保留
    
70. //[4]:标记上升沿是否已经被捕获
    
71. //[3:0]:溢出计时器
    4 E$ J$ ]1 q( t; O, R, _  o
72. u8         RmtSta=0;
    
73. u16 Dval;                //下降沿时计数器的值
    - i4 W+ W4 ~9 j7 X
74. u32 RmtRec=0;        //红外接收到的数据
    / s9 @& v- r4 {3 v1 B3 E4 _
75. u8  RmtCnt=0;        //按键按下的次数
    / k9 n8 e1 j1 N) w; f
76. //定时器4中断服务程序
    % E. Q0 U9 _& c* L& \3 t; I' C1 \9 ]
77. void TIM3_IRQHandler(void)
    
78. {
    
79.     if(TIM_GetITStatus(TIM3,TIM_IT_Update)!=RESET)        //更新中断
    ) p5 x) q9 O, p: n7 G+ l& P4 m
80.     {
    
81.         if(RmtSta&(1<<7))                                                                //上次有数据被接收到了
    9 [" v% ?3 b: c2 R- i
82.         {
    ( ?: ^1 a$ t: p: F! k3 J! o/ @
83.             RmtSta&=~(1<<4);                                                        //取消上升沿已经被捕获标记
    
84.             if((RmtSta&0X0F)==0X00)RmtSta|=1<<6;                //标记已经完成一次按键的键值信息采集
    3 H( \! `& y- z# P' u3 A
85.             if((RmtSta&0X0F)<14)RmtSta++;
    : Z6 |9 u5 g* T+ P) p' ?
86.             else
    
87.             {
    
88.                 RmtSta&=~(1<<7);                                        //清空引导标识
    4 k# W( c8 I: a( e
89.                 RmtSta&=0XF0;                                                //清空计数器
    
90.             }
    
91.         }
    
92.     }
    3 B: W, Q, E/ w& M' [
93.     if(TIM_GetITStatus(TIM3,TIM_IT_CC3)!=RESET)
    
94.     {
      _6 W8 Q2 I% M+ \( j: \
95.         if(NEC_READ_RX())//上升沿捕获
    
96.         {
    8 P* i" Y4 m3 p; }+ c0 A
97.             TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC3P=1        设置为下降沿捕获
    * Y* F* J4 i# r" H" S6 L/ K
98.             TIM_SetCounter(TIM3,0);                                        //清空定时器值
    
99.             RmtSta|=(1<<4);                                                        //标记上升沿已经被捕获
    
100.         }
     
101.                 else //下降沿捕获
     % N. l5 ^1 L) i- X1 ?0 z
102.         {
     - S; V  V: p' O( v; y
103.             Dval=TIM_GetCapture3(TIM3);                                //读取CCR3也可以清CC3IF标志位
     
104.             TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Rising);                                //CC3P=0        设置为上升沿捕获
     , Z  H& X- A. _1 N! o
105.             if(RmtSta&0X10)                                                        //完成一次高电平捕获
     
106.             {
     - I# n$ m, W$ A1 n2 V" H/ x, v$ X
107.                 if(RmtSta&(1<<7))//接收到了引导码
     1 c6 o5 ~( ?4 f$ p* L2 z
108.                 {
     ; Z9 B% K3 x, x9 ~
109.                     if(Dval>NEC_ZERO_MIN && Dval<NEC_ZERO_MAX){                        //560为标准值,560us
     6 S, u/ e& J; a( S% `
110. 
     
111.                         RmtRec<<=1;                                        //左移一位.
     
112.                         RmtRec|=0;                                        //接收到0
     0 i0 E  t% A& ?# T$ T/ N  M
113.                     }
     
114.                                         else if(Dval>NEC_ONE_MIN && Dval<NEC_ONE_MAX){        //1680为标准值,1680us
     + j4 @5 r0 m3 D  d2 q% S- t
115. 
       W" B7 ]; u4 N4 r
116.                         RmtRec<<=1;                                        //左移一位.
     
117.                         RmtRec|=1;                                        //接收到1
     
118.                     }
     % x+ D3 ]4 Y) z% n5 e  R- P. Z
119.                                         else if(Dval>NEC_CONTINUE_MIN && Dval<NEC_CONTINUE_MAX){        //得到按键键值增加的信息 2500为标准值2.5ms
     
120. 
     ; ]( ~) w( O$ j  m7 m, k2 V
121.                         RmtCnt++;                                         //按键次数增加1次
     / {; o. @9 t) l6 d6 z8 _. X
122.                         RmtSta&=0XF0;                                //清空计时器
     ! c, K* Z; ^8 a, d6 T8 a7 {( O
123.                     }
     
124.                 }
     
125.                                 else if(Dval>NEC_HEAD_MIN&&Dval<NEC_HEAD_MAX)                //4500为标准值4.5ms
     2 q2 s% ]  R; i, z+ c
126.                 {
     " L* {% D6 D; q( M
127.                     RmtSta|=1<<7;                                        //标记成功接收到了引导码
     
128.                     RmtCnt=0;                                                //清除按键次数计数器
     : {+ x2 ^) Y7 g0 S6 F& s
129.                 }
     
130.             }
     7 f9 B* [6 ?9 b# [% s, U/ ?  y
131.             RmtSta&=~(1<<4);
     , z2 s! p3 z6 A8 P# B3 A
132.         }
     
133.     }
     7 E- ]7 Y0 ?6 O; p) r1 l
134.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update|TIM_IT_CC3);
     / l6 j$ @* C0 `7 E
135. }
     $ g8 V( N6 z3 E8 V& Q8 D
136. 
     
137. void NEC_GetValue(u16 *addr,u16 *value)
     
138. {
     % m! F! k* W# C
139.     u8 t1,t2;
     7 s2 |! {. y& r. S) ]! q* T  \
140.         *addr = 0;
       D% G2 W7 `+ _% N5 _! v6 Z
141.         *value = 0;
     
142.     if(RmtSta&(1<<6)){                        //得到一个按键的所有信息了
     
143. 
     
144.         t1=RmtRec>>24;                        //得到地址码
     9 N, k* W+ _/ s; [- T
145.         t2=(RmtRec>>16)&0xff;        //得到地址反码
     
146.         if(t1==(u8)~t2)        {                //检验遥控识别码(ID)及地址
     % u. w0 p7 e0 t( A9 M
147. 
     
148.                         *addr = (t1<<8) | (t2);
     
149.             t1=RmtRec>>8;
     1 R: q0 L; l; K! A* k7 l6 M
150.             t2=RmtRec;
     
151.             if(t1==(u8)~t2){                        
     
152.                                 *value = (t1<<8) | (t2);
     + ?! R. p+ q2 B* P0 |/ o% g  a- u
153.                         }
     
154.                         else{
     ! E, O8 O+ K# z; y2 o6 [
155.                                 *addr = 0;
     4 P, d5 M3 _" E7 d
156.                                 *value=0;
     & G0 Z5 j: I! |% t7 l
157.                         }
     % }3 S# e0 ^6 T7 F4 [$ u
158.         }
     
159.         if((*value==0)||((RmtSta&(1<<7))==0)){//按键数据错误/遥控已经没有按下了
     
160. 
     
161.             RmtSta&=~(1<<6);//清除接收到有效按键标识
     
162.             RmtCnt=0;                //清除按键次数计数器
     
163.         }
     ! V- N% k  b( \. _2 M5 b; c
164.     }
     
165. }

复制代码

5 o+ |4 u. i7 M7 |& i" v接收部分在配置上比较简单，配置一个1us计数拼了，周期为10000（也就是10ms）的计数器，同时开启更新中断和捕获中断，
$ u- s. q) r& F! N
) ?$ |' o, E* A1 E0 J在更新中断，和捕获中断里面分别对接数据进行处理，这里要提一下就是捕获中断分上升沿捕获和下降沿捕获，在捕获到某一个电平后需要更新一下捕获的中断源。在每一次捕获的同时对时间间隔进行判断，判断的结果有引导码、数据码、重复码等，这里就不多解释了。

上发射部分代码：

8 P5 C0 O1 |& b1 j3 q# {

1. /****************************************************************************************/
   
2. #define CARRIER_38KHz() TIM_SetCompare4(TIM3,9)
   5 ], b- i) I  L0 {
3. #define NO_CARRIER()        TIM_SetCompare4(TIM3,0)
   
4. 
   
5. void NEC_TX_Configuration(void)            //红外传感器接收头引脚初始化
   1 k5 B1 L' j2 x; v2 d
6. {
   
7.     GPIO_InitTypeDef GPIO_InitStructure;
   & D  b" q( I5 |/ q. X9 Q' T/ F
8. 
   ' t  I7 f" {0 G7 L, p/ ^; V0 m: U
9.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   
10.         TIM_OCInitTypeDef  TIM_OCInitStructure;                                //输出比较        
    
11.         
    ) Y, l* }8 |+ ]; r9 M
12.     RCC_APB2PeriphClockCmd(NEC_TX_RCC,ENABLE);                         //使能PORT时钟
    
13.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);        //TIM3 时钟使能
    
14. 
    / f) d; v) \/ q" |3 y9 n
15.     GPIO_InitStructure.GPIO_Pin = NEC_TX_PIN;                        
    & {# d) f- ?( L) p# i. E8 q
16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         //复用推挽输出
    
17.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
18.     GPIO_Init(NEC_TX_PORT, &GPIO_InitStructure);
    
19. 
    
20.         TIM_Cmd(TIM3,DISABLE);
    7 N/ y6 ~; F  B7 d: E6 `
21.         TIM_ITConfig( TIM3,TIM_IT_Update|TIM_IT_CC3,DISABLE);                        //关闭TIM3中断
    0 C2 `! `5 Q: B2 b' O* R
22. 
      s5 _% M7 u  R" p
23.     TIM_TimeBaseStructure.TIM_Period = 25;                                                         //设定计数器自动重装值 最大10ms溢出
    
24.     TIM_TimeBaseStructure.TIM_Prescaler =71;                                                 //预分频器,1M的计数频率,1us加1.
    
25.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;                 //设置时钟分割:TDTS = Tck_tim
    7 _! p- g4 j- B8 _9 A. \
26.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;          //TIM向上计数模式
    + _: S" W5 B$ [# ~) A
27.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
    & R, C0 s6 u* G- I- {* ?
28. 
    7 ]( I+ Q# t  r( ]7 a
29.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                          //设置PWM1模式
    6 p3 r1 N  {. C7 v1 h
30.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //输出使能
    
31.         TIM_OCInitStructure.TIM_Pulse = 0;                                                            //设置捕获比较寄存器的值
    
32.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;          //设置有效电平为高电平
    
33.         TIM_OC4Init(TIM3, &TIM_OCInitStructure);                                           //生效初始化设置
    
34.         TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);                          //使能输出比较预装载
    , u, T# B7 G9 \4 ^
35.         
    ! b% O( O1 v/ G- b) T
36.         TIM_Cmd(TIM3,ENABLE);
    
37. }
    
38. 
    : S& P- a2 L- R: e
39. static void NEC_Send_Head(void){
    
40.         CARRIER_38KHz();        //比较值为1/3载波
    
41.         Delay_us(9000);
    ' @- Y/ e+ e( X+ b
42.         NO_CARRIER();        //不载波
    2 y5 w8 e/ S8 B4 q
43.         Delay_us(4500);
    - D, w5 G! P' A" K& t2 v
44. }
    
45. 
    ' b* f  x" N3 L% z
46. static void NEC_Send_BYTE(u8 value)
    + v7 u% C) j! u  L  H8 c0 C
47. {
    % U, v3 E. Y( ^- R
48.         u8 i;
      K' j; U/ u) X# m) v7 \
49.         
    5 ~7 K1 M+ C2 e8 \- R
50.         for(i=0;i<8;i++)
    
51.         {
    
52.                 if( value & 0x80 ){
    
53.                         CARRIER_38KHz();        //比较值为1/3载波
    
54.                         Delay_us(560);
    . N1 i- q$ ?- G; o9 d
55.                         NO_CARRIER();        //不载波
    
56.                         Delay_us(1680);
    
57.                 }
    
58.                 else{
    8 y# z  }! a& }7 q) `4 P
59.                         CARRIER_38KHz();        //比较值为1/3载波
    0 c# x6 Z8 k$ Y  Q) k
60.                         Delay_us(560);
    - O! g6 O4 z& R7 U+ d
61.                         NO_CARRIER();        //不载波
    ) F% ]" @- a& ]
62.                         Delay_us(560);
    3 n9 j6 o3 r, H3 C! Y! e
63.                 }
    
64.                 value<<=1;
    
65.         }
    
66. }
    
67. 
    ! I' V# `/ o+ t( {+ r' \
68. static void NEC_Send_Repeat(u8 repeatcnt)
    / n9 x. |3 t7 H# j& n
69. {
    
70.         u8 i;
    . O0 ~/ U+ a2 ^: \8 V% j4 W  X$ o
71.         
    
72.     if(repeatcnt==0)          //如果没有重复码就直接设置无载波，发射管进行空闲状态
    6 o7 N3 j8 Z: p& t( \
73.     {
    
74.         CARRIER_38KHz();
    
75.         Delay_us(560);
    
76.         NO_CARRIER();     
    
77.     }
    
78.         else
    
79.     {
    6 ]6 D* ?' a: g: H
80.         for(i=0;i<repeatcnt;++i)
    
81.         {
    
82.             CARRIER_38KHz();
    
83.             Delay_us(560);
    4 E: C4 }: j# H5 e; x! |
84.             NO_CARRIER();
    ( s$ C. t" ]8 l
85.             Delay_ms(98);
    
86.             CARRIER_38KHz();
    
87.             Delay_us(9000);  
    
88.             NO_CARRIER();
    4 B! W: P4 c( d  {# }
89.             Delay_us(2250);                     
    9 n( }" T  v6 l  t4 N0 A9 M+ V
90.         }
    
91. 
    
92.                 CARRIER_38KHz();
    ! j' Z9 R) Y+ |( u" o; n8 O
93.                 Delay_us(560);
    
94.                 NO_CARRIER();
    
95.     }
    ) Y8 S# p2 [0 F: D$ Q
96. }
    
97. 
    # |2 T7 W0 _- L+ C6 p5 @
98. 
    
99. void NEC_Send(u8 addr,u8 value,u8 cnt){
    5 c% l3 v0 |7 M: I
100. 
     
101.         NEC_TX_Configuration();
     
102.         
     % r  F5 {2 A2 o( X
103.         NEC_Send_Head();                                //发送起始码
     
104.         NEC_Send_BYTE(addr);                        //发送地址码H
     7 b+ D1 g; Q5 n1 T
105.         NEC_Send_BYTE(~addr);                        //发送地址码L
     6 l9 @1 A5 a7 _: r5 U1 y
106.         NEC_Send_BYTE(value);                        //发送命令码H
     
107.         NEC_Send_BYTE(~value);                        //发送命令码L
     3 C  C% f% T: K5 v, L
108.         NEC_Send_Repeat(cnt);                        //发送重复码        
     1 D/ V+ w. Z' ~7 l$ v
109. 
     
110.         NEC_RX_Configuration();
     ! _4 C* h/ |, N& R
111. }

复制代码

9 E5 p  N+ s. E+ z) M发送部分首先是重新配置定时器3，在配置里面计数频率依然是1us，也就是1MHz，计数周期修改成了25，也就是26个周期（0也算一个），这样算下来的话1MHz / 26 ≈ 38.4615KHz，这个跟红外接收差不多能匹配，当然红外接收头这里用的是38K的，所以配置成38K的，市面上也有不是38K的，比如36K，40K等。然后是载波，载波这里用的是差不多1/3的载波，从哪里可以体现呢？可以看到有这样一个宏定义：

1. #define CARRIER_38KHz() TIM_SetCompare4(TIM3,9)
   
2. #define NO_CARRIER()        TIM_SetCompare4(TIM3,0)

复制代码

载波的时候比较值设置的是9，没有载波的时候是0，9和26就约等于一个1/3的关系。

! q1 g  m$ [# o: u" ~  M最后就是发射部分，细节不说了，按照NEC协议进行发送，依次是引导码、地址码、地址反码、数据码、数据反码、重复码等。可以看到发射数据前后加了有NEC发送和NEC接收的配置，这里就是关键的分时部分，因为程序主要出于接收，在触发器（这里使用的按键）触发的时候才会发射红外数据。

上述就是NEC底层部分。上层应用也贴出来以供参考
& m& t) E# H( \3 \& A% m

1.                 keyvalue = Key_Scan();
   
2.                 if(keyvalue != KEY_NONE){
   
3.                         NEC_Send(taddr,tvalue,0);
   
4.                         taddr++;
   
5.                         tvalue++;
   
6.                 }
   ; Q8 s6 u0 z1 I  b! e" G  R- F$ \1 p
7.         
   
8.                 NEC_GetValue(&addr,&value);
   + r1 l" ?6 n2 q# Q0 C
9. 
   
10.                 if((value>>8)){
    - y. v! v: d; y4 w8 n! m5 F1 h  S$ X: L
11.                         printf(" %04x,%04x \r\n",addr,value);
    
12.                         printf(" addr: %d,key: %d,cnt: %d\r\n",(addr>>8),(value>>8),RmtCnt);
    $ I  S3 a2 e. D6 P( ]0 h
13.                         Oled_ShowNum(36,32,(addr>>8),3,8,16);
    
14.                         Oled_ShowNum(96,32,(value>>8),3,8,16);
    
15.                         Oled_ShowNum(36,48,RmtCnt,3,8,16);
    
16.                         Oled_RefreshGram();
    6 v  K7 F' t0 i/ w
17.                 }
    9 R# u5 j3 h% l5 y$ x
18. 
    
19.                 Delay_ms(10);
    3 [4 Y5 h; O$ O& e
20.                 if(++t==50){
    % v) |( T" K. b, l
21.                         t=0;
    
22.                         Led_Tog();
    
23.                 }

复制代码

! l$ ]! |& C" j: }7 G8 _最后要说一点的就是关于系统的延时，延时部分需要慎重，此处我也是踩了一坑，也一便记录下来。

原来的底层：

1. //u32 System_ms=0;
   8 n+ a, |; }0 \. q1 F0 B" A
2. 
   3 D0 u3 ~( Z: @  ?9 p: Q/ Q
3. //u32 usTicks;
   
4. //void Systick_Configuration(void)
   6 V) x4 A. x+ \/ k9 y( `! R6 j
5. //{
     P$ F4 {0 R1 y6 v7 I6 F7 F
6. //        RCC_ClocksTypeDef RCC_ClocksStucture;
   
7. //        RCC_GetClocksFreq(&RCC_ClocksStucture);        
   
8. //        usTicks = RCC_ClocksStucture.SYSCLK_Frequency/1000000;
   
9. //        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   + C: T6 ?/ y  X1 e$ M
10. //        SysTick_Config(RCC_ClocksStucture.SYSCLK_Frequency/1000);
    
11. //}
    
12. 
    
13. //u32 GetSystick_us(void)
    8 o& g% t- D1 e6 S) Q
14. //{
    
15. //        register u32 ms,cycle_cnt;
    ( h$ [) G3 H/ {  R
16. //        do{
    
17. //                ms = System_ms;
    
18. //                cycle_cnt = SysTick->VAL;
    
19. //        }while(ms != System_ms);
    
20. //        return (System_ms*1000) + (usTicks * 1000 - cycle_cnt) / usTicks;
    
21. //}
    
22. 
    3 Q, _& Q- v$ }1 {4 ?
23. //u32 GetSystick_ms(void)
    0 b7 A) j6 q/ {2 W, y
24. //{
    4 N7 Z5 @8 K* W8 b- J1 X
25. //        return System_ms;
    8 D6 Q7 s' Z4 p+ }% [1 [
26. //}
    
27. 
    
28. //void Delay_us(u32 nus)
    
29. //{
    
30. //        u32 now = GetSystick_us();
    ' ~9 k( _, m2 E+ X% u* G; f" }8 [
31. //        while(GetSystick_us() - now < nus);
    
32. //}
    
33. 
    . ?3 o6 c( q$ J/ E$ c! O
34. //void Delay_ms(u32 nms)
    3 t! G: j- p$ v. L
35. //{
    6 t0 U: j$ f  i$ P# Q. T
36. //        while(nms--)
    ( O! e! R% {2 d( A
37. //                Delay_us(1000);
    
38. //}
    
39. 
    
40. void SysTick_Handler(void)
    
41. {
    
42. //        System_ms++;
    0 [% l8 r2 ?# d% p  |6 @1 b* C8 Y
43. }

复制代码

这里用到的延时us和ms函数都会调用获取时基函数，这样的话ms还好一点，到us级别就不是很准，再有就是滴答中断里面也有时基去计数，再低级的中断那也是中断，会打断前台程序的运行。
2 \- M5 h, s- {( A& o$ v0 W  e
% p  m# c( @6 G# c' c( r7 m; g改过之后的：
9 n5 g/ A" Q' u. f1 N5 A
0 I! A2 G( ^9 ^: @8 C2 T& [) ~& r( I

1. void Systick_Configuration(void)
   
2. {
   # b% _; B3 M& g  U2 F
3.     SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //设置时钟源8分频
   . c, L) Q4 ]/ H8 F/ E; e
4.     SysTick->CTRL |= SysTick_CTRL_TICKINT_Msk;            //使能中断
   ! S$ X9 t' k5 j' i- M( U
5.     SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;             //开定时器
   
6.     SysTick->LOAD = 9;                                    //随意设置一个重装载值
   5 a" \6 O! L, l/ T7 J" k- s
7. }
   
8. 
   
9. 
   
10. void Delay_us(u32 xus)
    
11. {
    , Q) e; k' Y) @, X% m) F
12.     SysTick->LOAD = 9 * xus; //计9次为1us，xus则重装载值要*9
    
13.     SysTick->VAL = 0;        //计数器归零
    ! L6 Z% ]- I8 h% ~! s% P
14.     while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); //等待计数完成
    
15. }
    
16. 
    * @. O/ N: `0 ?+ P
17. 
    
18. void Delay_ms(u32 xms)
    8 h' R" q  Z2 X/ a; l+ T
19. {
    , \! p8 z3 c' L- q$ h) U, h: Q
20.     SysTick->LOAD = 9000; //计9次为1us，1000次为1ms
    2 c5 t% E2 W) Y- m; ?  Y9 Q+ N
21.     SysTick->VAL = 0;     //计数器归零
    : V( v* K4 h# u: h* G
22.     while (xms--)
    ; B" K( q8 s3 M+ U  r
23.     {
    & F: x0 e4 i7 {; f4 x& m
24.         while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); //等待单次计数完成
    / l3 _: B+ {( ^) F8 o: [
25.     }
    6 i" `7 K" L* b! U* c! U
26. }

复制代码

5 r; F. g9 T1 }3 I! [- @6 O这样的话中断依然打开，但是中断里是空的，其次延时函数也因为不调用获取时基直接判断寄存器而更加精确！