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

NEC的特征
1：使用38 kHz 载波频率
2：引导码间隔是9 ms + 4.5 ms
3：使用16 位客户代码
4：使用8 位数据代码和8 位取反的数据代码
* d) h. ]" [5 n, j: B
* ^, b& b0 v, N4 L. D1 b当发射器按键按下后，即有遥控码发出，所按的键不同遥控编码也不同。这种遥控码具有以下特征：采用脉宽调制的串行码，以脉宽为0.565ms、间隔0.56ms、周期为1.125ms的组合表示二进制的“0”；以脉宽为0.565ms、间隔1.685ms、周期为2.25ms的组合表示二进制的“1”，其波形如图所示。


3 M6 k1 Y+ }$ U+ `1 K; O
. g" i, h6 k) ]9 ?; G


$ ?# I" A- q( H这里我采用同一个定时器TIM3的两个通道分别用来做红外的接收和发送，接收用通道3的输入捕获，发送用通道4的输出比较，程序采用分时复用的方式完成收发一体的实验效果。默认处于接收状态，在按键触发时切换成发射状态发送红外数据，发送完成后再次默认切换成接收。
% g: n3 @" m$ p+ ?2 p
- x8 z! _9 x! v- O$ z! V& L上接收部分的代码：

1. #define NEC_HEAD                (u16)(4500)
   
2. #define NEC_ZERO                 (u16)(560)
   
3. #define NEC_ONE                        (u16)(1680)
   
4. #define NEC_CONTINUE         (u16)(2500)
   
5. 
   
6. #define NEC_HEAD_MIN (u16)(NEC_HEAD*0.8f)
   3 V6 Q9 J& i5 y  {* q( K0 P! t, E
7. #define NEC_HEAD_MAX (u16)(NEC_HEAD*1.2f)
   ( k( C, k* d0 _$ V
8. 
   
9. #define NEC_ZERO_MIN (u16)(NEC_ZERO*0.8f)
   
10. #define NEC_ZERO_MAX (u16)(NEC_ZERO*1.2f)
    
11. 
    
12. #define NEC_ONE_MIN (u16)(NEC_ONE*0.8f)
    ' m) Y1 n9 w  @% f+ Z% Q% [
13. #define NEC_ONE_MAX (u16)(NEC_ONE*1.2f)
    ' Y+ B  |4 b: r
14. 
    
15. #define NEC_CONTINUE_MIN (u16)(NEC_CONTINUE*0.8f)
    
16. #define NEC_CONTINUE_MAX (u16)(NEC_CONTINUE*1.2f)
    
17. 
    + z+ e4 s& m! N4 O( l
18. 
    % |: n! c8 d( e/ v- `# L
19. //红外遥控接收初始化
    / x: N! H- c0 f: A) h/ |
20. void NEC_RX_Configuration(void)
    4 @+ a6 @+ A. V, H
21. {
    
22.     GPIO_InitTypeDef GPIO_InitStructure;
    / U9 ~/ p4 \0 Z% q% f  ]& |
23.     NVIC_InitTypeDef NVIC_InitStructure;
    . H# a0 [3 Y' Z( x7 k4 w/ W
24.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    
25.     TIM_ICInitTypeDef  TIM_ICInitStructure;//输入捕获
    " M) R0 Y; I5 F& z: {8 v) P3 {
26.         
      j9 k5 W9 \! J8 v) _; g
27.     RCC_APB2PeriphClockCmd(NEC_RX_RCC|NEC_TX_RCC,ENABLE); //使能PORT时钟
    
28.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);         //TIM3 时钟使能
    & q7 j4 {. y2 h' @$ }. p9 B2 q
29.         
    + Z5 m3 z6 Z8 I/ c" K: s/ m: @! n
30.     GPIO_InitStructure.GPIO_Pin = NEC_RX_PIN;                        
    4 i6 q/ t' I/ d$ @( t
31.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;                  // 上拉输入
    
32.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ! A' y6 Y/ z3 m5 v, I. I1 `4 z' e% p
33.     GPIO_Init(NEC_RX_PORT, &GPIO_InitStructure);
    : s  z; _2 C+ D) v' x
34. 
    9 Z2 N, D, w1 e7 J7 V( s! N
35.     GPIO_InitStructure.GPIO_Pin = NEC_TX_PIN;                        
    ) F) |6 H! }2 c1 y1 I5 }
36.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出
    . a: ?& h- A9 b. ?; Y& N+ E% N; M" _
37.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
38.     GPIO_Init(NEC_TX_PORT, &GPIO_InitStructure);
    
39. 
    2 @3 E# {+ N8 X; `4 W( V& R  S
40.     TIM_TimeBaseStructure.TIM_Period = 10000; //设定计数器自动重装值 最大10ms溢出
    
41.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //预分频器,1M的计数频率,1us加1.
    ; j# [! U6 J0 f! n
42.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
    ' _; R: D/ W  \4 Q, e/ f: \  l
43.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    5 @0 j$ ?1 G6 r4 \. {5 }; `
44.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx
    
45. 
    1 m/ X6 `3 z: ~! |3 D, ^$ \8 g  _5 b
46.     TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;  // 选择输入端 IC3映射到TI3上
    
47.     TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
    8 j- @" N5 ~. Y4 J* q
48.     TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
    
49.     TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
    
50.     TIM_ICInitStructure.TIM_ICFilter = 0x03;//IC4F=0011 配置输入滤波器 8个定时器时钟周期滤波
    
51.     TIM_ICInit(TIM3, &TIM_ICInitStructure);//初始化定时器输入捕获通道
    + J7 M! P6 e) {
52. 
    + h" A& K& ?0 B+ G; ^# ~
53.     NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
    
54.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级2级
    
55.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  //从优先级
    
56.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
    
57.     NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    ' O( s% ?: z+ B& e+ Q  I: ]
58. 
    6 l9 ~- m5 F% Y9 |7 Z* Z
59.     TIM_ITConfig( TIM3,TIM_IT_Update|TIM_IT_CC3,ENABLE);//允许更新中断 ,允许CC3IE捕获中断
    
60.         
    0 ~: f: b+ m/ o: o& K
61.         TIM_ARRPreloadConfig(TIM3,ENABLE);        //重装载
    % S$ m5 A" E5 I1 Z
62. 
    
63.     TIM_Cmd(TIM3,ENABLE );         //使能定时器3
    5 i" k4 \/ L6 C, @9 s
64. }
    
65. 
    
66. //遥控器接收状态
    
67. //[7]:收到了引导码标志
    
68. //[6]:得到了一个按键的所有信息
    
69. //[5]:保留
    3 v9 I$ F3 D! Y5 p1 q& X0 N
70. //[4]:标记上升沿是否已经被捕获
    % \/ f( F) B+ j6 T, B' ~; g9 T7 M' q/ M
71. //[3:0]:溢出计时器
    " f; g5 @3 ]8 T, Y2 Y
72. u8         RmtSta=0;
    3 s5 d9 ^7 w2 _, Z- l: S# ?" k+ o) F
73. u16 Dval;                //下降沿时计数器的值
    ' {) u) i" \% y
74. u32 RmtRec=0;        //红外接收到的数据
    # o- ^/ G6 k9 |
75. u8  RmtCnt=0;        //按键按下的次数
    
76. //定时器4中断服务程序
    
77. void TIM3_IRQHandler(void)
    
78. {
    ( f% }& @8 [- h3 u
79.     if(TIM_GetITStatus(TIM3,TIM_IT_Update)!=RESET)        //更新中断
    - [, r3 J# l* F
80.     {
    & V1 v% v1 G- o. ], f
81.         if(RmtSta&(1<<7))                                                                //上次有数据被接收到了
    + l* k* L- r$ `) W
82.         {
    
83.             RmtSta&=~(1<<4);                                                        //取消上升沿已经被捕获标记
    
84.             if((RmtSta&0X0F)==0X00)RmtSta|=1<<6;                //标记已经完成一次按键的键值信息采集
    
85.             if((RmtSta&0X0F)<14)RmtSta++;
    
86.             else
    
87.             {
    + l2 {9 U1 F/ Z$ L  x" _
88.                 RmtSta&=~(1<<7);                                        //清空引导标识
    
89.                 RmtSta&=0XF0;                                                //清空计数器
    9 E6 X' L+ k4 F- J$ ^% A
90.             }
    
91.         }
    4 K3 X  k9 \/ k3 }
92.     }
    
93.     if(TIM_GetITStatus(TIM3,TIM_IT_CC3)!=RESET)
    ! l( |! ?5 ?) B8 P; ]4 p
94.     {
    
95.         if(NEC_READ_RX())//上升沿捕获
    4 K  }0 Q7 V* O( \
96.         {
    1 M6 ~: k" {6 {% j: V
97.             TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC3P=1        设置为下降沿捕获
    
98.             TIM_SetCounter(TIM3,0);                                        //清空定时器值
    
99.             RmtSta|=(1<<4);                                                        //标记上升沿已经被捕获
    
100.         }
     / ?2 v( y* w# P5 y- A( K. Y
101.                 else //下降沿捕获
     
102.         {
     * A) P: W  S  t( K7 f
103.             Dval=TIM_GetCapture3(TIM3);                                //读取CCR3也可以清CC3IF标志位
     
104.             TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Rising);                                //CC3P=0        设置为上升沿捕获
     
105.             if(RmtSta&0X10)                                                        //完成一次高电平捕获
     
106.             {
     8 W3 D' X! f5 h& a
107.                 if(RmtSta&(1<<7))//接收到了引导码
     
108.                 {
     # J; o6 X' b3 j$ r7 y
109.                     if(Dval>NEC_ZERO_MIN && Dval<NEC_ZERO_MAX){                        //560为标准值,560us
     
110. 
     0 I+ O1 A, B% o+ U0 E1 X: z$ E
111.                         RmtRec<<=1;                                        //左移一位.
     
112.                         RmtRec|=0;                                        //接收到0
     
113.                     }
     
114.                                         else if(Dval>NEC_ONE_MIN && Dval<NEC_ONE_MAX){        //1680为标准值,1680us
     ' |5 n) a6 [- B' l0 i) @
115. 
     
116.                         RmtRec<<=1;                                        //左移一位.
     5 W5 U6 [. a5 r3 C
117.                         RmtRec|=1;                                        //接收到1
     
118.                     }
     ( r' T/ ^* f$ }, w) `8 D2 y
119.                                         else if(Dval>NEC_CONTINUE_MIN && Dval<NEC_CONTINUE_MAX){        //得到按键键值增加的信息 2500为标准值2.5ms
     
120. 
     
121.                         RmtCnt++;                                         //按键次数增加1次
     
122.                         RmtSta&=0XF0;                                //清空计时器
     6 S5 \  @& a, m( ^( x" |
123.                     }
     
124.                 }
     
125.                                 else if(Dval>NEC_HEAD_MIN&&Dval<NEC_HEAD_MAX)                //4500为标准值4.5ms
     / T& I2 `% _4 y* ?! L. U' y
126.                 {
     
127.                     RmtSta|=1<<7;                                        //标记成功接收到了引导码
     
128.                     RmtCnt=0;                                                //清除按键次数计数器
     ' b; F* G$ q. T% K9 L! s5 u
129.                 }
     : v! P( q9 p/ A5 k/ f( ?
130.             }
     ' r8 @( O' ?' v3 ]5 P
131.             RmtSta&=~(1<<4);
     
132.         }
     % j, }9 L; E- T/ H( b& U* ?
133.     }
     
134.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update|TIM_IT_CC3);
     
135. }
     2 a1 ~! l- Q7 Q( t1 B" K  M1 l
136. 
     
137. void NEC_GetValue(u16 *addr,u16 *value)
     : z8 z+ J% o- c) Q7 b$ k# }  f
138. {
     . _* p4 ]- r! G$ T
139.     u8 t1,t2;
     4 _# @9 Q- e+ c
140.         *addr = 0;
     
141.         *value = 0;
     
142.     if(RmtSta&(1<<6)){                        //得到一个按键的所有信息了
     
143. 
     # w4 P" L7 T$ q# t* [8 i6 r
144.         t1=RmtRec>>24;                        //得到地址码
     : V. B" U+ @( x" y+ @$ }6 Q' S4 d% w
145.         t2=(RmtRec>>16)&0xff;        //得到地址反码
     % U' I" g/ \" y9 {0 u* ~( b
146.         if(t1==(u8)~t2)        {                //检验遥控识别码(ID)及地址
     - Q, ~( D) P# h- b8 P
147. 
     : X' ~  Q, x7 w$ W3 h
148.                         *addr = (t1<<8) | (t2);
     
149.             t1=RmtRec>>8;
     0 B$ s6 ]% l# ^/ r/ N
150.             t2=RmtRec;
     7 {$ U  a/ \6 U% q: A( _; ~/ ?
151.             if(t1==(u8)~t2){                        
     7 C# i. j1 ]+ p4 b/ E8 @1 n" R
152.                                 *value = (t1<<8) | (t2);
     
153.                         }
     
154.                         else{
     
155.                                 *addr = 0;
     
156.                                 *value=0;
     
157.                         }
     
158.         }
     + m. a; {: Q. `( Z( V9 p3 b0 Y
159.         if((*value==0)||((RmtSta&(1<<7))==0)){//按键数据错误/遥控已经没有按下了
     ( t& A* J3 m0 ?4 N* K
160. 
     
161.             RmtSta&=~(1<<6);//清除接收到有效按键标识
       v" |) o9 r# B* N  Q9 q! L: S
162.             RmtCnt=0;                //清除按键次数计数器
     # \# X5 A. A' x4 Q* K  t
163.         }
     . `% t; _+ R, [% [" B
164.     }
     
165. }

复制代码

0 O. l5 _/ B  I* S8 N0 e接收部分在配置上比较简单，配置一个1us计数拼了，周期为10000（也就是10ms）的计数器，同时开启更新中断和捕获中断，

6 P3 N6 d- d8 g( z在更新中断，和捕获中断里面分别对接数据进行处理，这里要提一下就是捕获中断分上升沿捕获和下降沿捕获，在捕获到某一个电平后需要更新一下捕获的中断源。在每一次捕获的同时对时间间隔进行判断，判断的结果有引导码、数据码、重复码等，这里就不多解释了。
) C7 @7 q, `- O( f& Z+ R! v  K! e
上发射部分代码：

& ^, _3 ~  C4 n8 ^8 c+ i

1. /****************************************************************************************/
   
2. #define CARRIER_38KHz() TIM_SetCompare4(TIM3,9)
   
3. #define NO_CARRIER()        TIM_SetCompare4(TIM3,0)
   3 h5 U$ O+ R1 n# Y3 W: A
4. 
   
5. void NEC_TX_Configuration(void)            //红外传感器接收头引脚初始化
   ( H7 |9 E9 ^; f, Y8 E: k" J3 S% f
6. {
   
7.     GPIO_InitTypeDef GPIO_InitStructure;
   - R0 r- E/ {2 A$ w! I; |8 Q- J
8. 
   5 V* X" V9 N" e1 e6 \% o
9.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   . N: A" u) N) b+ h, \
10.         TIM_OCInitTypeDef  TIM_OCInitStructure;                                //输出比较        
    " R/ K3 B; n; t, q- F* O0 I$ z
11.         
    
12.     RCC_APB2PeriphClockCmd(NEC_TX_RCC,ENABLE);                         //使能PORT时钟
    " o! q/ D; y" {" I/ q2 v; E
13.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);        //TIM3 时钟使能
    
14. 
    * B  P# C9 Y- N3 |
15.     GPIO_InitStructure.GPIO_Pin = NEC_TX_PIN;                        
    
16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         //复用推挽输出
    6 r+ I) D* i8 @' r( o
17.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
18.     GPIO_Init(NEC_TX_PORT, &GPIO_InitStructure);
    
19. 
    
20.         TIM_Cmd(TIM3,DISABLE);
    : M! m1 M" `- Z& V" T
21.         TIM_ITConfig( TIM3,TIM_IT_Update|TIM_IT_CC3,DISABLE);                        //关闭TIM3中断
    9 ~- _4 e" U9 }9 u
22. 
    8 U9 P2 ?/ y' ?, a, c7 T
23.     TIM_TimeBaseStructure.TIM_Period = 25;                                                         //设定计数器自动重装值 最大10ms溢出
    ) S0 V' U; I8 m& D1 u
24.     TIM_TimeBaseStructure.TIM_Prescaler =71;                                                 //预分频器,1M的计数频率,1us加1.
    
25.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;                 //设置时钟分割:TDTS = Tck_tim
    
26.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;          //TIM向上计数模式
    
27.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
    
28. 
    : {1 f2 O6 w/ k  w& p! b& Q
29.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                          //设置PWM1模式
    ' W$ l* y0 C1 ^8 C1 `# C- a* b
30.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //输出使能
    , H, A- C# C2 `4 D' e
31.         TIM_OCInitStructure.TIM_Pulse = 0;                                                            //设置捕获比较寄存器的值
    
32.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;          //设置有效电平为高电平
    9 ?& x' t: ^; ~" }: g- _
33.         TIM_OC4Init(TIM3, &TIM_OCInitStructure);                                           //生效初始化设置
    
34.         TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);                          //使能输出比较预装载
    
35.         
    4 w) _# l; A* a" Z& |
36.         TIM_Cmd(TIM3,ENABLE);
    6 E2 I# e0 H9 Y9 e2 I# j& N  v* I
37. }
    
38. 
    
39. static void NEC_Send_Head(void){
    
40.         CARRIER_38KHz();        //比较值为1/3载波
    
41.         Delay_us(9000);
    , {* p& T( [, g& z2 J) X
42.         NO_CARRIER();        //不载波
    ( C. \- _9 q9 y% V/ Q) \
43.         Delay_us(4500);
    5 d) c4 S) T, o, j6 F
44. }
    
45. 
    
46. static void NEC_Send_BYTE(u8 value)
    8 R2 q- e3 i# Z. R& v
47. {
    ( v0 n6 p! y2 D) I
48.         u8 i;
    
49.         
    
50.         for(i=0;i<8;i++)
    ! y1 m/ ^  V: ?# @" v& e
51.         {
    
52.                 if( value & 0x80 ){
      \1 c  ^  G1 A6 y* ^2 n% {
53.                         CARRIER_38KHz();        //比较值为1/3载波
    5 j5 `. a9 g3 c4 z; k: H
54.                         Delay_us(560);
    
55.                         NO_CARRIER();        //不载波
    
56.                         Delay_us(1680);
    
57.                 }
    . Q; F+ }5 h- E/ p! z
58.                 else{
    . K4 U: H$ J- h" a# T; ^
59.                         CARRIER_38KHz();        //比较值为1/3载波
    
60.                         Delay_us(560);
    
61.                         NO_CARRIER();        //不载波
    
62.                         Delay_us(560);
    
63.                 }
    6 h2 C5 k* z) z# h: i) D7 r
64.                 value<<=1;
    , e9 D- _2 k6 H/ R* W; B
65.         }
    
66. }
    . E5 y7 c3 V- E3 T9 I7 q
67. 
    / @& {; N8 ]8 g9 Y* K
68. static void NEC_Send_Repeat(u8 repeatcnt)
    ; g/ t1 i; H; C9 j
69. {
    
70.         u8 i;
    
71.         
    
72.     if(repeatcnt==0)          //如果没有重复码就直接设置无载波，发射管进行空闲状态
    7 l5 E( p. J- m6 b
73.     {
    
74.         CARRIER_38KHz();
    
75.         Delay_us(560);
    ; c: k( X8 F: A% K. j( T
76.         NO_CARRIER();     
    
77.     }
    , i6 |! g: R. E: O
78.         else
    4 C# ?1 x. A! i) C$ x9 b/ \
79.     {
    
80.         for(i=0;i<repeatcnt;++i)
    * D  X3 f; S0 X
81.         {
    * p3 ~- ]! D# Z  K
82.             CARRIER_38KHz();
    + d. B- V9 R  E$ _$ W2 e6 J8 [
83.             Delay_us(560);
    9 F6 e: {: Y' ?, z
84.             NO_CARRIER();
    - O. I$ V; N9 [
85.             Delay_ms(98);
    1 i5 S: @0 V1 \" W
86.             CARRIER_38KHz();
    7 k. n# E  T0 `% d5 q7 K
87.             Delay_us(9000);  
    % Z, @: h/ v7 Y  Y
88.             NO_CARRIER();
    / w4 z$ w# E: A
89.             Delay_us(2250);                     
    
90.         }
    0 k; Q7 g" o1 h8 S, j" P% i
91. 
    
92.                 CARRIER_38KHz();
    / n3 e, y4 C: w5 w8 U
93.                 Delay_us(560);
    ! ^  T, a5 c  E, b0 w2 D1 O
94.                 NO_CARRIER();
    6 V* i, o. H# [/ j& d
95.     }
    
96. }
    $ o  W$ B6 j9 \# _& B
97. 
    
98. 
    
99. void NEC_Send(u8 addr,u8 value,u8 cnt){
    
100. 
     4 Z0 R* l" L6 w) ~/ U
101.         NEC_TX_Configuration();
     1 T( }4 m" p/ B3 O8 |/ S5 Z/ |
102.         
     
103.         NEC_Send_Head();                                //发送起始码
     # P( |; k. a1 X6 ?. y8 H! V
104.         NEC_Send_BYTE(addr);                        //发送地址码H
     2 x. `+ {, D% P# O
105.         NEC_Send_BYTE(~addr);                        //发送地址码L
     1 f) Y+ m6 ?) B0 B/ o
106.         NEC_Send_BYTE(value);                        //发送命令码H
     
107.         NEC_Send_BYTE(~value);                        //发送命令码L
     
108.         NEC_Send_Repeat(cnt);                        //发送重复码        
     
109. 
     
110.         NEC_RX_Configuration();
     
111. }

复制代码

发送部分首先是重新配置定时器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)

复制代码

% ^2 b6 |* d  D载波的时候比较值设置的是9，没有载波的时候是0，9和26就约等于一个1/3的关系。
5 d! n4 _! r' z" q
$ u0 X' H# B. T% w5 L5 T最后就是发射部分，细节不说了，按照NEC协议进行发送，依次是引导码、地址码、地址反码、数据码、数据反码、重复码等。可以看到发射数据前后加了有NEC发送和NEC接收的配置，这里就是关键的分时部分，因为程序主要出于接收，在触发器（这里使用的按键）触发的时候才会发射红外数据。
/ A  D3 c5 o2 e* v
9 K# W& v. _$ S$ w上述就是NEC底层部分。上层应用也贴出来以供参考
+ h+ T# M9 S* S& q: U9 e' L
/ j' ^7 ^! H6 G2 P+ C3 Y
, e" j  L* z) W

1.                 keyvalue = Key_Scan();
   
2.                 if(keyvalue != KEY_NONE){
   
3.                         NEC_Send(taddr,tvalue,0);
   ; F  H" t6 @, l# h4 x$ B7 ^
4.                         taddr++;
   0 _, D/ k( e& d
5.                         tvalue++;
   & x: k8 n4 h8 X  P% i1 I
6.                 }
   ; B( I0 G8 Q- f" k7 K
7.         
   
8.                 NEC_GetValue(&addr,&value);
   5 n. {0 q, r; ?
9. 
   , h4 j# y' U/ V: h
10.                 if((value>>8)){
    
11.                         printf(" %04x,%04x \r\n",addr,value);
      X# ]- R  L4 y8 k, p
12.                         printf(" addr: %d,key: %d,cnt: %d\r\n",(addr>>8),(value>>8),RmtCnt);
    
13.                         Oled_ShowNum(36,32,(addr>>8),3,8,16);
    " q8 s1 U2 p. i0 ~! F/ Z  y8 b
14.                         Oled_ShowNum(96,32,(value>>8),3,8,16);
    + }/ A$ ]3 ~; V# d
15.                         Oled_ShowNum(36,48,RmtCnt,3,8,16);
    
16.                         Oled_RefreshGram();
    
17.                 }
    5 j' d8 S1 i: \( O. [# g- O. ?  m
18. 
    ) `* w( H- j- o. g  x) O; h* E
19.                 Delay_ms(10);
    - e- }/ |' R8 P+ d% y5 g
20.                 if(++t==50){
    8 y" N9 n: A' J) B2 U
21.                         t=0;
    ! Z" s! f) D7 ~7 t) M/ Q' u
22.                         Led_Tog();
    
23.                 }

复制代码

最后要说一点的就是关于系统的延时，延时部分需要慎重，此处我也是踩了一坑，也一便记录下来。

7 s3 J# \$ @8 B( p9 z8 E# I9 W+ A" Y原来的底层：
+ ~" t7 z4 k& z9 t3 H

1. //u32 System_ms=0;
   
2. 
   , D9 u3 C* {% [$ T' e0 A
3. //u32 usTicks;
   
4. //void Systick_Configuration(void)
   8 n' Z! n% f! h* c+ V3 d' `
5. //{
   # \# _# a8 \, B" s- I7 w4 W" u
6. //        RCC_ClocksTypeDef RCC_ClocksStucture;
   
7. //        RCC_GetClocksFreq(&RCC_ClocksStucture);        
   
8. //        usTicks = RCC_ClocksStucture.SYSCLK_Frequency/1000000;
   6 c. Y4 k$ t  S, K
9. //        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   
10. //        SysTick_Config(RCC_ClocksStucture.SYSCLK_Frequency/1000);
    : e# u- [+ m, e1 q$ |
11. //}
    
12. 
    
13. //u32 GetSystick_us(void)
    
14. //{
    
15. //        register u32 ms,cycle_cnt;
    
16. //        do{
      v. A0 h8 @  C$ _; B
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. 
    
23. //u32 GetSystick_ms(void)
    0 b2 r8 o0 U8 z& O' D. z5 L7 k
24. //{
    , a) _3 R9 J8 ^* |
25. //        return System_ms;
    0 G! W1 e3 f2 T% K2 s
26. //}
    
27. 
    + q' j! |0 p, E: I. U( z. r6 e9 w
28. //void Delay_us(u32 nus)
    
29. //{
    * @- F0 F3 t- O3 h5 q
30. //        u32 now = GetSystick_us();
      P2 N, K* p, }% m- I2 i
31. //        while(GetSystick_us() - now < nus);
    + ]# U& r% Z- N3 r; B
32. //}
    
33. 
    ' D) j1 ~7 ~- O5 O: q- r2 u( K
34. //void Delay_ms(u32 nms)
    
35. //{
    
36. //        while(nms--)
    $ r6 v: G- @! o$ w# `3 t
37. //                Delay_us(1000);
    
38. //}
    
39. 
    
40. void SysTick_Handler(void)
    / y; l/ ?+ s' W7 J5 j! }% r
41. {
    
42. //        System_ms++;
    7 `& y. |+ g7 z/ r
43. }

复制代码

8 [+ K4 C- e0 f) K- \. l这里用到的延时us和ms函数都会调用获取时基函数，这样的话ms还好一点，到us级别就不是很准，再有就是滴答中断里面也有时基去计数，再低级的中断那也是中断，会打断前台程序的运行。

改过之后的：

' y: Z5 @9 \, }9 w# {

1. void Systick_Configuration(void)
   * w1 I2 S1 j& B. C9 C. q
2. {
   
3.     SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //设置时钟源8分频
   
4.     SysTick->CTRL |= SysTick_CTRL_TICKINT_Msk;            //使能中断
   
5.     SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;             //开定时器
   
6.     SysTick->LOAD = 9;                                    //随意设置一个重装载值
   
7. }
   
8. 
   " G. d: d' j0 T# m8 T% ]5 U
9. 
   
10. void Delay_us(u32 xus)
      @) B) k4 |' m5 s/ n' Y
11. {
    3 |9 I+ E; V; h
12.     SysTick->LOAD = 9 * xus; //计9次为1us，xus则重装载值要*9
    6 K7 ^# W6 E* ~
13.     SysTick->VAL = 0;        //计数器归零
    
14.     while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); //等待计数完成
    $ ~- Z+ {. Q+ u% W6 p8 i
15. }
    
16. 
    
17. 
    2 D, I$ m7 V! |+ b
18. void Delay_ms(u32 xms)
    
19. {
    
20.     SysTick->LOAD = 9000; //计9次为1us，1000次为1ms
    ! w7 S- z- P" i; m3 r
21.     SysTick->VAL = 0;     //计数器归零
    
22.     while (xms--)
    
23.     {
    9 i+ @  x8 ?* [* z& f  ^/ u  T. t
24.         while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); //等待单次计数完成
    2 M- P! j  v" T4 Y
25.     }
    
26. }

复制代码

3 N* p/ G! s7 s# U' i* `这样的话中断依然打开，但是中断里是空的，其次延时函数也因为不调用获取时基直接判断寄存器而更加精确！


9 R6 `* Q5 W5 P9 J