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

4 }# R( ~% D/ p, I) WNEC的特征
1：使用38 kHz 载波频率
2：引导码间隔是9 ms + 4.5 ms
3：使用16 位客户代码
4：使用8 位数据代码和8 位取反的数据代码
' ^. {% a+ C# r! }8 Q1 y+ G  G
: p& x8 ^# ?7 p  Q3 p0 x当发射器按键按下后，即有遥控码发出，所按的键不同遥控编码也不同。这种遥控码具有以下特征：采用脉宽调制的串行码，以脉宽为0.565ms、间隔0.56ms、周期为1.125ms的组合表示二进制的“0”；以脉宽为0.565ms、间隔1.685ms、周期为2.25ms的组合表示二进制的“1”，其波形如图所示。

4 ^2 }$ k" P" x- k0 b3 Z
% e  ?* P% p- m# Y; {: M- E
: G! N, {' m% l) W1 [/ K5 [

8 g; c% S  K6 g. m2 m& I
" v; _: ]( b0 W# @% R3 O这里我采用同一个定时器TIM3的两个通道分别用来做红外的接收和发送，接收用通道3的输入捕获，发送用通道4的输出比较，程序采用分时复用的方式完成收发一体的实验效果。默认处于接收状态，在按键触发时切换成发射状态发送红外数据，发送完成后再次默认切换成接收。

上接收部分的代码：
* a4 E6 w% d& ]; Q7 e

1. #define NEC_HEAD                (u16)(4500)
   6 r0 _( Q/ |. M2 ~  M# I7 h
2. #define NEC_ZERO                 (u16)(560)
   2 o$ H1 F( }) t9 ^7 Z5 Z# i
3. #define NEC_ONE                        (u16)(1680)
   
4. #define NEC_CONTINUE         (u16)(2500)
   4 O* s4 k# T& k  f/ [9 v4 p
5. 
   
6. #define NEC_HEAD_MIN (u16)(NEC_HEAD*0.8f)
   
7. #define NEC_HEAD_MAX (u16)(NEC_HEAD*1.2f)
   3 G6 e$ s( Q* g8 x- f, }7 L
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)
    1 r* m7 ?  Q) q  Z4 A7 t9 R
13. #define NEC_ONE_MAX (u16)(NEC_ONE*1.2f)
    2 s/ @% B6 N5 }1 I$ N
14. 
    & F6 y4 b, R! s( ?) k- M
15. #define NEC_CONTINUE_MIN (u16)(NEC_CONTINUE*0.8f)
    , q% b) E& i$ s
16. #define NEC_CONTINUE_MAX (u16)(NEC_CONTINUE*1.2f)
    + E0 s  U: J$ T6 ~5 G" T5 x( r
17. 
    1 }& g9 y& F7 Z8 S- P" s6 W
18. 
    
19. //红外遥控接收初始化
    
20. void NEC_RX_Configuration(void)
    
21. {
    " }0 R' n" P/ W% N3 z9 K) B% U1 Z
22.     GPIO_InitTypeDef GPIO_InitStructure;
    
23.     NVIC_InitTypeDef NVIC_InitStructure;
      s4 G/ k) h: f4 t5 I# S
24.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    3 e# f  ^5 _; p0 t0 a
25.     TIM_ICInitTypeDef  TIM_ICInitStructure;//输入捕获
    ( ~8 ^; c2 M1 ^9 m3 H$ f) V/ c
26.         
    " y# `0 _# E$ \! y: c
27.     RCC_APB2PeriphClockCmd(NEC_RX_RCC|NEC_TX_RCC,ENABLE); //使能PORT时钟
    $ ], u6 R! a8 B6 t* M
28.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);         //TIM3 时钟使能
    1 X: Y$ Q: u: y9 K+ p
29.         
    
30.     GPIO_InitStructure.GPIO_Pin = NEC_RX_PIN;                        
    
31.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;                  // 上拉输入
    
32.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
33.     GPIO_Init(NEC_RX_PORT, &GPIO_InitStructure);
    
34. 
    ) d. h* h3 ?0 O4 h" m; A
35.     GPIO_InitStructure.GPIO_Pin = NEC_TX_PIN;                        
    1 {: H- s5 v, F) {8 s% z
36.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出
    
37.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
38.     GPIO_Init(NEC_TX_PORT, &GPIO_InitStructure);
    
39. 
    , }7 n) h. R' D2 s, G) \
40.     TIM_TimeBaseStructure.TIM_Period = 10000; //设定计数器自动重装值 最大10ms溢出
    
41.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //预分频器,1M的计数频率,1us加1.
    
42.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
    3 S; S0 H: Z0 I* U0 m# H$ x* K7 T
43.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    
44.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx
    
45. 
    8 l; @8 H! F' f' N
46.     TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;  // 选择输入端 IC3映射到TI3上
    
47.     TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
    ) V# Q. Z# q4 ]0 j! [
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个定时器时钟周期滤波
    2 L0 O! m5 L* u6 v% H! v# s
51.     TIM_ICInit(TIM3, &TIM_ICInitStructure);//初始化定时器输入捕获通道
    6 z( E: G  S6 }$ z, I( E' O
52. 
    
53.     NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
    
54.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级2级
    
55.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  //从优先级
    $ N5 n) F7 k: l$ H7 Y# y
56.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
    1 z3 h. N4 V; l/ ~4 l, n6 ^
57.     NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    5 O/ H: [/ h6 p
58. 
    1 x* E* p  h5 x7 }( d: L
59.     TIM_ITConfig( TIM3,TIM_IT_Update|TIM_IT_CC3,ENABLE);//允许更新中断 ,允许CC3IE捕获中断
    
60.         
    ( ~6 X2 r$ T9 q  W
61.         TIM_ARRPreloadConfig(TIM3,ENABLE);        //重装载
    1 D0 H+ c/ X" a+ f- ]
62. 
    
63.     TIM_Cmd(TIM3,ENABLE );         //使能定时器3
    
64. }
    + z; R/ N; A) A7 _* ^6 e+ \) f$ s
65. 
    , o$ y1 J7 M: F: ^3 u
66. //遥控器接收状态
    . R, Z* Y! x: A4 {$ O
67. //[7]:收到了引导码标志
    
68. //[6]:得到了一个按键的所有信息
    ' m% ]: A: d# ^8 ?& b% B- W1 n
69. //[5]:保留
    , t# e  c6 R+ u/ i8 i1 w
70. //[4]:标记上升沿是否已经被捕获
    ! x) g/ }- ?- F( j9 y3 U4 @
71. //[3:0]:溢出计时器
    " ~6 r8 p& B" B3 T
72. u8         RmtSta=0;
    
73. u16 Dval;                //下降沿时计数器的值
    
74. u32 RmtRec=0;        //红外接收到的数据
    
75. u8  RmtCnt=0;        //按键按下的次数
    
76. //定时器4中断服务程序
    ) T- ~0 W9 ?- M: X( }; j7 V- S
77. void TIM3_IRQHandler(void)
    ) g0 H( B! @2 ?% L# y
78. {
    + g5 _2 u# Z2 ^% J" C! X- e
79.     if(TIM_GetITStatus(TIM3,TIM_IT_Update)!=RESET)        //更新中断
    , I( l$ |, `% b% T% {) F& l* F
80.     {
    
81.         if(RmtSta&(1<<7))                                                                //上次有数据被接收到了
    / \+ I3 u( L- S: d$ _
82.         {
    
83.             RmtSta&=~(1<<4);                                                        //取消上升沿已经被捕获标记
    
84.             if((RmtSta&0X0F)==0X00)RmtSta|=1<<6;                //标记已经完成一次按键的键值信息采集
    ) F( r& H% c) H9 W, R2 |$ m8 i
85.             if((RmtSta&0X0F)<14)RmtSta++;
    
86.             else
    
87.             {
    
88.                 RmtSta&=~(1<<7);                                        //清空引导标识
    * g- P# f  J/ f2 B3 s5 W' l  t
89.                 RmtSta&=0XF0;                                                //清空计数器
    , B- ?" i( s" @) R9 k
90.             }
    . X: E- T, H9 [& k& \5 l/ ~# e+ ^
91.         }
    ' C3 n( ]# r3 e
92.     }
    
93.     if(TIM_GetITStatus(TIM3,TIM_IT_CC3)!=RESET)
    ) o! p8 X$ R. U- |/ {
94.     {
    
95.         if(NEC_READ_RX())//上升沿捕获
    
96.         {
    
97.             TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC3P=1        设置为下降沿捕获
      I7 q9 A) p9 i3 W0 z# x1 U, h
98.             TIM_SetCounter(TIM3,0);                                        //清空定时器值
    
99.             RmtSta|=(1<<4);                                                        //标记上升沿已经被捕获
    ' V3 x1 a5 L9 d
100.         }
     
101.                 else //下降沿捕获
     2 a; E3 p  l: G
102.         {
     - T* ~9 q, P7 ?5 m* a$ [
103.             Dval=TIM_GetCapture3(TIM3);                                //读取CCR3也可以清CC3IF标志位
     
104.             TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Rising);                                //CC3P=0        设置为上升沿捕获
     - x, m9 [9 s1 R; u- w) ?
105.             if(RmtSta&0X10)                                                        //完成一次高电平捕获
     
106.             {
     8 a+ o% G/ T- H! ^# ]
107.                 if(RmtSta&(1<<7))//接收到了引导码
     
108.                 {
     
109.                     if(Dval>NEC_ZERO_MIN && Dval<NEC_ZERO_MAX){                        //560为标准值,560us
     # F; D6 x) r% J& `4 z0 ]5 j/ n
110. 
     2 o: s( S/ Z1 A
111.                         RmtRec<<=1;                                        //左移一位.
     
112.                         RmtRec|=0;                                        //接收到0
     & `( i; C6 @6 `2 p
113.                     }
     . ?6 b$ q' k* d+ @, n+ {& P3 W
114.                                         else if(Dval>NEC_ONE_MIN && Dval<NEC_ONE_MAX){        //1680为标准值,1680us
     
115. 
     
116.                         RmtRec<<=1;                                        //左移一位.
     ( J) A  D% Z) s- G
117.                         RmtRec|=1;                                        //接收到1
     1 o4 C+ \7 u2 B" J, F
118.                     }
     
119.                                         else if(Dval>NEC_CONTINUE_MIN && Dval<NEC_CONTINUE_MAX){        //得到按键键值增加的信息 2500为标准值2.5ms
     
120. 
     
121.                         RmtCnt++;                                         //按键次数增加1次
     & E, t. r, Z  F  y" e0 Y
122.                         RmtSta&=0XF0;                                //清空计时器
     : o. f/ Q" K4 H7 Z* X
123.                     }
     9 F' K' Y4 n( d+ Z) |
124.                 }
     
125.                                 else if(Dval>NEC_HEAD_MIN&&Dval<NEC_HEAD_MAX)                //4500为标准值4.5ms
     $ I  M% f2 O- Y" J6 \& L. k
126.                 {
     - B* n8 i3 c5 u* |
127.                     RmtSta|=1<<7;                                        //标记成功接收到了引导码
     - D  G; l( [" k: e- X- h9 \
128.                     RmtCnt=0;                                                //清除按键次数计数器
     
129.                 }
     
130.             }
     
131.             RmtSta&=~(1<<4);
     ' {% {4 ^- h, Y# i4 b1 h- k
132.         }
     ( y% N/ m& H: z7 |/ W  O
133.     }
     " m9 M1 D: Q/ t* I
134.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update|TIM_IT_CC3);
       k+ x6 y  q1 S8 `% c
135. }
     3 D, M) i$ N+ c5 A1 f+ Y0 Z: C1 E" J
136. 
     / x0 K4 d# S) O9 F0 o3 ?' |# j
137. void NEC_GetValue(u16 *addr,u16 *value)
     
138. {
     0 s+ k- k. Z, n' k1 o, r! R/ c+ m
139.     u8 t1,t2;
     
140.         *addr = 0;
     2 i' I2 X: e. Q0 m) c  |
141.         *value = 0;
     
142.     if(RmtSta&(1<<6)){                        //得到一个按键的所有信息了
     - e0 B: m/ \6 i8 z" C( M6 H
143. 
     1 V% d4 o( u" n6 A1 Z8 t
144.         t1=RmtRec>>24;                        //得到地址码
     
145.         t2=(RmtRec>>16)&0xff;        //得到地址反码
     
146.         if(t1==(u8)~t2)        {                //检验遥控识别码(ID)及地址
     
147. 
     ) O& L  b8 u# y! ]  C9 {6 G
148.                         *addr = (t1<<8) | (t2);
     ) k7 Q2 D+ c3 g4 D* \
149.             t1=RmtRec>>8;
     , W8 H8 F" Q! t. E' n5 Q
150.             t2=RmtRec;
     ; |7 k. v# C# x3 ?3 G+ [) S, t! E; R, K
151.             if(t1==(u8)~t2){                        
     2 o8 g( o8 e0 P- \
152.                                 *value = (t1<<8) | (t2);
     
153.                         }
     " N, Z6 c2 u4 {8 B; D
154.                         else{
     3 m3 s' D- B' F" e" V+ D" R0 Z
155.                                 *addr = 0;
     
156.                                 *value=0;
     
157.                         }
     $ {; F0 D7 [( ~- M
158.         }
     - S: S# O7 t5 E+ m
159.         if((*value==0)||((RmtSta&(1<<7))==0)){//按键数据错误/遥控已经没有按下了
     4 t" @; h; }/ y0 e; K
160. 
     3 n9 H' C: Y6 |- f$ z
161.             RmtSta&=~(1<<6);//清除接收到有效按键标识
     
162.             RmtCnt=0;                //清除按键次数计数器
     
163.         }
     
164.     }
     3 K3 k' n" k$ b9 R; b( d+ T2 s
165. }

复制代码

1 m$ ]' a/ k" u# {' o# p1 F1 }9 v% l接收部分在配置上比较简单，配置一个1us计数拼了，周期为10000（也就是10ms）的计数器，同时开启更新中断和捕获中断，
3 d  `; I/ J& L& Z/ W6 i/ p0 Y
在更新中断，和捕获中断里面分别对接数据进行处理，这里要提一下就是捕获中断分上升沿捕获和下降沿捕获，在捕获到某一个电平后需要更新一下捕获的中断源。在每一次捕获的同时对时间间隔进行判断，判断的结果有引导码、数据码、重复码等，这里就不多解释了。

上发射部分代码：
: N7 l4 {1 F" t6 L( a& J; ]! v
; ]7 _- x- Z' }% v" V& l# ^

1. /****************************************************************************************/
   7 p6 z$ x# p/ [' X
2. #define CARRIER_38KHz() TIM_SetCompare4(TIM3,9)
   * P8 L( [$ E) A7 S3 {5 l5 @
3. #define NO_CARRIER()        TIM_SetCompare4(TIM3,0)
   
4. 
   
5. void NEC_TX_Configuration(void)            //红外传感器接收头引脚初始化
   
6. {
   ' f& I9 F* e; s2 K- b
7.     GPIO_InitTypeDef GPIO_InitStructure;
   
8. 
   - N' P% D. }1 ]$ M+ Q
9.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   
10.         TIM_OCInitTypeDef  TIM_OCInitStructure;                                //输出比较        
    7 d6 o/ b' o: p7 H' P) h
11.         
    . H: i4 U2 Q1 N" }, q
12.     RCC_APB2PeriphClockCmd(NEC_TX_RCC,ENABLE);                         //使能PORT时钟
    
13.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);        //TIM3 时钟使能
    $ \9 O: o: f/ K. O& h" N
14. 
    
15.     GPIO_InitStructure.GPIO_Pin = NEC_TX_PIN;                        
    0 B- F& r8 k# ?, B
16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         //复用推挽输出
    9 d; R4 c* H+ {& l' N+ }
17.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
18.     GPIO_Init(NEC_TX_PORT, &GPIO_InitStructure);
    7 I& W* O2 C' K& l
19. 
    
20.         TIM_Cmd(TIM3,DISABLE);
    - E  K& |& x! w$ J; _: K( m7 r" @
21.         TIM_ITConfig( TIM3,TIM_IT_Update|TIM_IT_CC3,DISABLE);                        //关闭TIM3中断
    4 L* z, i/ X+ H- }, g
22. 
    & z! B6 o4 s0 ~
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
    ! A  a  a0 E8 o1 x" T
26.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;          //TIM向上计数模式
    0 H1 C8 C7 c( t" J
27.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
    
28. 
    
29.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                          //设置PWM1模式
    
30.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //输出使能
    - t/ Z8 n# a/ c9 r4 `8 E7 Y
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);                          //使能输出比较预装载
    
35.         
    5 N0 b" C9 W7 u  G, u3 A2 Q7 A: j
36.         TIM_Cmd(TIM3,ENABLE);
    + G* H( M) D9 t
37. }
    
38. 
    
39. static void NEC_Send_Head(void){
    
40.         CARRIER_38KHz();        //比较值为1/3载波
    
41.         Delay_us(9000);
    . f6 L$ j6 I6 \/ }: K. M. P/ s
42.         NO_CARRIER();        //不载波
    
43.         Delay_us(4500);
    0 ~, K* E/ b( A4 k# D
44. }
    
45. 
    
46. static void NEC_Send_BYTE(u8 value)
    9 d& z. b4 L: c6 R3 }% I3 {  j
47. {
    
48.         u8 i;
    
49.         
    / {  C: P1 B4 T0 q
50.         for(i=0;i<8;i++)
    . ^0 X& |# a% B  Q  |
51.         {
    4 h0 Q8 f7 t- S3 P7 X& C+ `
52.                 if( value & 0x80 ){
    
53.                         CARRIER_38KHz();        //比较值为1/3载波
    
54.                         Delay_us(560);
    
55.                         NO_CARRIER();        //不载波
    
56.                         Delay_us(1680);
    $ i+ U8 f: Z# W: n8 x# M
57.                 }
    5 b' C8 a" h- J$ k; `. H. C: n
58.                 else{
    7 X9 M% A* d& x. h( ~
59.                         CARRIER_38KHz();        //比较值为1/3载波
    # V8 U# @1 w5 j/ q0 U0 j
60.                         Delay_us(560);
    1 N9 t! e6 F3 w4 j/ C2 K
61.                         NO_CARRIER();        //不载波
    4 R* P) z- b1 H- E
62.                         Delay_us(560);
    
63.                 }
    
64.                 value<<=1;
    ; f8 w4 @- b' J$ j, \' k6 n
65.         }
    2 s, e, v) ^' U' S) ]( e
66. }
    
67. 
    - q3 \+ d4 a+ ]7 Q9 s" r+ l8 V
68. static void NEC_Send_Repeat(u8 repeatcnt)
    - K8 Y2 a* L) M" X; _& r" l
69. {
    
70.         u8 i;
    % b& T: @% t3 h6 M) J
71.         
    
72.     if(repeatcnt==0)          //如果没有重复码就直接设置无载波，发射管进行空闲状态
    - _/ V: e4 z6 G1 w$ J) T4 P
73.     {
    % B' v7 O; m7 G- H" m; r
74.         CARRIER_38KHz();
    
75.         Delay_us(560);
    
76.         NO_CARRIER();     
    
77.     }
    ! Z+ @% b, {3 B% v1 p7 h% w* A
78.         else
    
79.     {
    : i8 O: J9 E# j
80.         for(i=0;i<repeatcnt;++i)
    : \- I" l1 x% X1 F$ [+ @
81.         {
    
82.             CARRIER_38KHz();
    
83.             Delay_us(560);
    " Z3 ?2 [9 L- ?( ~- O
84.             NO_CARRIER();
    
85.             Delay_ms(98);
    , T  U8 ^0 n- r8 a" a
86.             CARRIER_38KHz();
    1 Z1 E4 U3 g8 e6 t
87.             Delay_us(9000);  
    
88.             NO_CARRIER();
    + ^- @% ^" [$ m. ]* Y5 R
89.             Delay_us(2250);                     
    
90.         }
    
91. 
    & j, f& ?7 _4 g) g5 A( t
92.                 CARRIER_38KHz();
    1 k% {: P# D# H' ^* ^) @
93.                 Delay_us(560);
    
94.                 NO_CARRIER();
    0 \; X/ U" ?/ n" n
95.     }
    
96. }
    
97. 
    
98. 
    7 {4 ~  }: [# f7 ]  K
99. void NEC_Send(u8 addr,u8 value,u8 cnt){
    
100. 
     
101.         NEC_TX_Configuration();
     : h$ ~! G9 H( O" {/ W5 `* w' d$ z# V1 n
102.         
     
103.         NEC_Send_Head();                                //发送起始码
     . n! {) _# v2 z  g& F% u
104.         NEC_Send_BYTE(addr);                        //发送地址码H
     ! I! L6 p0 N$ x# b5 c" |
105.         NEC_Send_BYTE(~addr);                        //发送地址码L
     6 M8 n4 ^$ P$ b" W6 e( `% @% [. Z
106.         NEC_Send_BYTE(value);                        //发送命令码H
     
107.         NEC_Send_BYTE(~value);                        //发送命令码L
     
108.         NEC_Send_Repeat(cnt);                        //发送重复码        
     6 q4 l" q# W- Q& t: @& }5 `# q
109. 
     - k0 J8 D2 `/ s; x, W
110.         NEC_RX_Configuration();
     " I. c5 Z+ M6 M7 A
111. }

复制代码

, e) A4 u( E( s! }/ @5 I  k发送部分首先是重新配置定时器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)

复制代码

# `1 _4 Y4 G$ ?# {- r1 Z载波的时候比较值设置的是9，没有载波的时候是0，9和26就约等于一个1/3的关系。

6 G9 ~7 N" t, v4 o9 q最后就是发射部分，细节不说了，按照NEC协议进行发送，依次是引导码、地址码、地址反码、数据码、数据反码、重复码等。可以看到发射数据前后加了有NEC发送和NEC接收的配置，这里就是关键的分时部分，因为程序主要出于接收，在触发器（这里使用的按键）触发的时候才会发射红外数据。
" p0 B2 F, j9 h0 x
上述就是NEC底层部分。上层应用也贴出来以供参考
" B5 v0 ~8 X) ~* ~" |/ J7 N

1.                 keyvalue = Key_Scan();
   
2.                 if(keyvalue != KEY_NONE){
   
3.                         NEC_Send(taddr,tvalue,0);
   
4.                         taddr++;
   : p* k9 Q( w; C5 T+ n- O
5.                         tvalue++;
   . W1 z9 W1 g# _: r$ n
6.                 }
   4 f' F9 @4 X: ]) P+ H, F" X
7.         
   ; ?8 g9 A$ Z" r  M! Y; `. k
8.                 NEC_GetValue(&addr,&value);
   
9. 
   , I% S& U- U+ [" K: ~1 b5 @2 w: j
10.                 if((value>>8)){
    
11.                         printf(" %04x,%04x \r\n",addr,value);
    
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);
    ( ]6 T) y+ a8 L+ V8 z
14.                         Oled_ShowNum(96,32,(value>>8),3,8,16);
    - g- w' ?" f: o( g. P5 ~
15.                         Oled_ShowNum(36,48,RmtCnt,3,8,16);
    & V$ N8 O2 e7 ]0 M3 W
16.                         Oled_RefreshGram();
    " M  _& s2 h$ a" J" k  t! I" P! ^/ U
17.                 }
    0 o5 u3 n5 ?; e2 ?
18. 
    
19.                 Delay_ms(10);
    
20.                 if(++t==50){
    
21.                         t=0;
    
22.                         Led_Tog();
    ) F7 V" {* J3 }7 _4 J  ]
23.                 }

复制代码

! w- t6 r! F9 {" @- n  X' F最后要说一点的就是关于系统的延时，延时部分需要慎重，此处我也是踩了一坑，也一便记录下来。

* _& b+ z! k+ I& }$ }原来的底层：

1. //u32 System_ms=0;
   
2. 
   : ^7 k) U) q+ E' o8 C* _* h
3. //u32 usTicks;
   
4. //void Systick_Configuration(void)
   
5. //{
   1 G* o6 ^$ R; |( o+ o9 p/ ]. ^
6. //        RCC_ClocksTypeDef RCC_ClocksStucture;
   / Y; e0 b, ?5 `
7. //        RCC_GetClocksFreq(&RCC_ClocksStucture);        
   ) R2 i) }+ l- A  Z
8. //        usTicks = RCC_ClocksStucture.SYSCLK_Frequency/1000000;
   ' O5 V3 @8 d+ h6 P
9. //        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   
10. //        SysTick_Config(RCC_ClocksStucture.SYSCLK_Frequency/1000);
    
11. //}
    ! I3 W7 U* U' D, T/ F; v5 y
12. 
    4 N, s; E4 P+ }
13. //u32 GetSystick_us(void)
      m' [. i! x% A1 R
14. //{
    0 a, E% O! j0 z+ B& B
15. //        register u32 ms,cycle_cnt;
    4 y! h+ Q# a# {- k2 ]  a8 z
16. //        do{
    
17. //                ms = System_ms;
    & k' z% ?0 a6 {6 p/ q
18. //                cycle_cnt = SysTick->VAL;
    % y9 ?1 H! i6 ]
19. //        }while(ms != System_ms);
    # y& ~, G1 U3 F" t* J( n% g# R
20. //        return (System_ms*1000) + (usTicks * 1000 - cycle_cnt) / usTicks;
    + q& ]' |8 U0 I8 F" d: A" L
21. //}
    
22. 
    $ k9 Y2 O7 y( X- p7 l) Y3 r0 F7 `: _
23. //u32 GetSystick_ms(void)
    
24. //{
    ! B+ q) N* G8 d- f/ e
25. //        return System_ms;
    ' i5 E; T, t1 q2 f) C
26. //}
    0 X& R  @* H8 H0 ~9 b
27. 
    
28. //void Delay_us(u32 nus)
    & D% h3 @6 r8 s" p  F
29. //{
    
30. //        u32 now = GetSystick_us();
    & l9 L% k1 |( S+ ?) v" O" m8 H& Y. d
31. //        while(GetSystick_us() - now < nus);
    ! x8 i6 c6 @' V
32. //}
    
33. 
    
34. //void Delay_ms(u32 nms)
    
35. //{
    6 y9 O# y( [- W9 s7 Z
36. //        while(nms--)
    
37. //                Delay_us(1000);
    
38. //}
    
39. 
    . m' C& o: g% k) G; k
40. void SysTick_Handler(void)
    9 e$ @; r8 ~/ S: L+ D) @0 Q
41. {
    , c' f3 U1 P) A  ]9 K* i
42. //        System_ms++;
    : w+ o7 C+ v. ~$ C- `& D
43. }

复制代码

( ^  j9 }- t+ v9 U& |, S这里用到的延时us和ms函数都会调用获取时基函数，这样的话ms还好一点，到us级别就不是很准，再有就是滴答中断里面也有时基去计数，再低级的中断那也是中断，会打断前台程序的运行。

0 t. p) i3 q& B改过之后的：
& u9 y( A; V; X: a: j

1. void Systick_Configuration(void)
   
2. {
   5 z" K) X5 ^6 y+ ]1 @% c: f
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. }
   3 Q4 k9 a$ u" d  @7 R
8. 
   
9. 
   
10. void Delay_us(u32 xus)
    
11. {
    
12.     SysTick->LOAD = 9 * xus; //计9次为1us，xus则重装载值要*9
      {8 T7 D* _" P& I8 c9 O7 L
13.     SysTick->VAL = 0;        //计数器归零
    
14.     while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); //等待计数完成
    ) F+ v  `3 s+ [; H* m  _) l/ a
15. }
    
16. 
    
17. 
    ' U8 T3 K1 J7 t* Z) k' V8 D
18. void Delay_ms(u32 xms)
    3 `. M4 b! ?! h+ M: _+ K  V5 H
19. {
    , S+ Y2 Q7 {- J" A' W/ N  K) e! z
20.     SysTick->LOAD = 9000; //计9次为1us，1000次为1ms
    
21.     SysTick->VAL = 0;     //计数器归零
    
22.     while (xms--)
    ; ~+ E+ h1 ~- `5 ]$ Y* y
23.     {
    
24.         while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); //等待单次计数完成
    
25.     }
    & b2 @0 ~& f: K
26. }

复制代码

这样的话中断依然打开，但是中断里是空的，其次延时函数也因为不调用获取时基直接判断寄存器而更加精确！
& H# j# ]. L( `- T" e2 x) {( e
1 n; o7 A( {# M/ Z. H. {' A/ G8 A
1 ~. f' N- N; W3 X  @+ d