1 序言

    很早前就想实现这个红外遥控自学习的这个实验，用于来自己控制房子里如空调等红外遥控设备的自动化，NEC的标准到具体的产品上可能就被厂家定义为不一样了，所以自学习就应该是接收到什么就发送什么，不用管内容是什么！

2 硬件实现原理

    由上述原理图可知，当IE为高电平时发送红外光，为低电平时不发送红外光。

    在NEC协议中，信息传输是基于38K载波，也就是说红外线是以载波的方式传递。

    发送波形如下图所示：

    NEC协议规定：

• 发送协议数据“0” = 发送载波560us + 不发送载波560us
• 发送协议数据“1” = 发送载波560us+ 不发送载波1680us
• 发送引导码 = 发送载波9000us + 不发送载波4500us
  
  # V+ E% m* o* M9 e/ o0 \" z
  1 a9 Z+ S5 ?6 O8 M% u3 T

     在红外接收端，如果接收到红外38K载波，则IR输出为低电平，如果不是载波包括固定低电平和固定高电平则输出高电平。在IR端接收的信号如下所示：

3 软件实现自学习

    设计原理：

    1、 根据接收波形记录电平和电平持续时间，以便于发送。

    2、电平记录采用定时器捕获功能，从下降沿接收引导信号开始，每触发一次改变触发方式，从而使每个电平变化都能捕获到。

    源码实现如下：

    定时器捕获初始化设置（CubeMax软件自动配置生成）：

1. void MX_TIM4_Init(void)
   8 P& v. T" P3 y, d  w- u
2. {
   
3. TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   
4. TIM_MasterConfigTypeDef sMasterConfig = {0};
   
5. TIM_IC_InitTypeDef sConfigIC = {0};
   7 V5 c+ ]" o4 p0 Z
6. 
   
7. 
   3 T/ _: z! a& w5 E2 d" _
8. htim4.Instance = TIM4;
   
9. htim4.Init.Prescaler = 71;
   
10. htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
    
11. htim4.Init.Period = 10000;
    8 \' b1 L7 Y) _6 k/ P
12. htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
13. htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    ) Q2 q* D4 s9 i* g- c
14. if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    1 f5 a( [% h% {" [+ M9 d
15. {
    
16. Error_Handler();
    - x4 {% U9 _$ |! a) d
17. }
    
18. sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    0 C7 T4 G3 h7 k" G7 v
19. if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    
20. {
    : V7 E0 P: p4 f2 U, B* Z/ G
21. Error_Handler();
    7 I- Z1 g- O. V$ m
22. }
    
23. if (HAL_TIM_IC_Init(&htim4) != HAL_OK)
    8 z! C" ~% O& L/ m$ I# ], a( B
24. {
    1 g9 @  }4 R* G% ~! |
25. Error_Handler();
    
26. }
    
27. sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    $ J. r+ S+ q$ z, o1 D& f
28. sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
29. if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    
30. {
    
31. Error_Handler();
    " P# J. ~5 s. ^' x4 m3 p! v% W
32. }
    
33. sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
    , f9 K( t+ B* v7 d. `4 u4 w
34. sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
    
35. sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
    
36. sConfigIC.ICFilter = 0;
    1 v2 T2 ~, ~  t6 |5 j
37. if (HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_4) != HAL_OK)
    
38. {
    . u  w5 v6 I& r3 ^9 h
39. Error_Handler();
      W7 _1 _# Q7 y+ `2 F
40. }
    - \$ M0 {1 B7 J$ M6 g/ c5 }
41. 
    
42. 
    & s' K1 U& D0 F0 l0 h1 |6 i
43. }

复制代码

    定时器捕获中断回调处理：

1. void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
   - H: T! ]( N' p( ?+ M; Y. b3 k, h1 u
2. {
     {1 R5 c! u& d4 O: h9 A
3. if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4)
   + ~: p/ J7 J* f4 Y: Y
4.     {
   ( ]5 n/ b1 H% G7 t/ }  b$ E/ v/ q, C* i
5. if(TIM4->CCER & (TIM_CCER_CC4P))   //下降沿触发
   
6.         {
   
7.             TIM4->CCER &= ~(TIM_CCER_CC4P); //切换
   * q; `$ k, {9 A6 i/ ]
8.             gu8BitVal = 1;
   
9.         }
   
10. else                               //上升沿触发
    
11.         {
    , {9 c! A9 h( W) r! N# J1 G& ]
12.             TIM4->CCER |= TIM_CCER_CC4P;    //切换
    
13.             gu8BitVal = 0;
    
14.         }
    : O1 m- f; l- m! M3 Y
15. 
    5 D1 b: O1 b5 x, I* q- z" |/ @
16. 
    3 R! P7 q( d. X- Q4 C
17. 
    ( B7 t. k; ?4 i& i
18. 
    
19. if(gsInfrared.State == NONE_STATE)
    
20.         {
    8 F2 ]  }4 R( e& C6 i  |
21.             gsInfrared.State = RECV_STATE;
    
22.         }
    
23. else if(gsInfrared.State == RECV_STATE)
    ! Y6 F" i& U( l- K& Z
24.         {
    
25.             NowTimCnt = HAL_TIM_ReadCapturedValue(&htim4, TIM_CHANNEL_4);
    
26.             gsInfrared.KeepTime[gsInfrared.SampleCount] = Round(NowTimCnt);
    
27.             gsInfrared.BitValue[gsInfrared.SampleCount ++] = gu8BitVal;
    7 m1 s- `3 k& q. R1 @9 l5 I9 R3 P( C
28.         }
    7 |1 O' D6 z+ h# Y/ W5 k1 h
29. 
    " y, K8 A& R6 a! x  `- h" M
30. 
    
31.         TIM4->CNT = 0;
    / p5 n4 |- }6 H2 m0 Q+ ~( E
32.     }
    ' R9 }9 {6 m0 t: j
33. }

复制代码

    3、设置的定时器溢出时间为10ms，如果10毫秒内不再接收电平变化则默认接收结束，设置结束标志。

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   ' U& z2 B% o. c+ B. O7 k9 K1 I
2. {
   
3. if(htim == &htim4)
   
4.     {
   : r9 V9 {9 E; y) z3 F
5. if(gsInfrared.State == RECV_STATE)
   
6.         {
   ) ^* l* R. a+ k  X- Q0 @
7.             gsInfrared.State = END_STATE;
   
8.         }
   6 T2 W  g% X! m/ z, D
9.     }
   
10. }

复制代码

    至此，实现了红外遥控的学习功能，获得的记录数据为记录长度和电平信号数组与电平信号维持的时间数组。

    4、发送实现

    设置定时器输出38KPWM信号，在记录电平为0是输出记录时间的38K载波信号，如果为1则不输出载波，实现如下：

    PWM生成设置（CubeMax自动配置生成）：

1. void MX_TIM5_Init(void)
   
2. {
   + j7 b0 M' |8 a' w
3.   TIM_MasterConfigTypeDef sMasterConfig = {0};
   / M( @% d1 Z# `9 ]. s# }
4.   TIM_OC_InitTypeDef sConfigOC = {0};
   
5. 
   2 Z, z  |' C* \6 E9 ^
6. 
   
7.   htim5.Instance = TIM5;
   5 j' o* e2 g- t/ B7 h% _+ d
8.   htim5.Init.Prescaler = 0;
   
9.   htim5.Init.CounterMode = TIM_COUNTERMODE_UP;
   
10.   htim5.Init.Period = 1896;
    
11.   htim5.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    1 w( i* \7 ]. g
12.   htim5.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    ; q* y2 B- J4 ^& P. J
13. if (HAL_TIM_PWM_Init(&htim5) != HAL_OK)
    7 L6 f" {+ u8 V" M+ B3 C: o2 U
14.   {
    + y8 e# A4 d+ E7 K$ a$ I& [4 K
15.     Error_Handler();
    
16.   }
    ' M1 e: D* W& ?% U- @% ]
17.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    ) n$ D' b2 u  B9 V- _
18.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
19. if (HAL_TIMEx_MasterConfigSynchronization(&htim5, &sMasterConfig) != HAL_OK)
    1 b/ ]) I, ?1 V# b. b/ _: U
20.   {
    . ?) L  n% V' h2 R9 |: ?
21.     Error_Handler();
    
22.   }
    ; ~5 u5 {. K/ X
23.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
    ; t+ t; s& Q; X  J' m5 O, @
24.   sConfigOC.Pulse = 0;
    
25.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    
26.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    
27. if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
    
28.   {
    1 r5 P  K( T5 G" |8 s
29.     Error_Handler();
    # ^- V; y8 \5 X# C: n
30.   }
    ) i1 E. G$ ?: p, A0 n
31.   HAL_TIM_MspPostInit(&htim5);
    / U  `2 j7 {6 _  D
32. 
    
33. 
    4 d, m; p! U% {4 B& g7 l3 ^3 J; d
34. }

复制代码

    发送实现，注意点就是记录为0时发载波，记录为1时不发载波：

1. void InfraredSend(void)
   
2. {
   5 P' R- n# H8 O+ B
3. uint16_t Count = 0;
   
4. 
   4 m' G' ~) ]& f0 O1 L
5. while(Count < gsInfrared.SampleCount &&  gsInfrared.State == END_STATE)
   " P6 _1 a6 k; @9 u/ `
6.     {
   
7. if(gsInfrared.BitValue[Count] == 0)
   
8.         {
   4 V& [) |: J5 ~' I
9.             TIM5->CCR2 = 948;
   
10.             delay_us(gsInfrared.KeepTime[Count]);
    
11.             TIM5->CCR2 = 0;
    " \, G6 @( _2 q2 @; {7 ]* T
12.         }
    
13. else
    ' `8 U& x7 c6 X2 k" X/ L
14.         {
    
15.             TIM5->CCR2 = 0;
    % o( a4 ^  k! u+ {" `- l
16.             delay_us(gsInfrared.KeepTime[Count]);
    
17.             TIM5->CCR2 = 0;
    % r) G& L$ ]6 _" y
18.         }
    
19. 
    ) O, T3 W, }" j, S& u
20. 
    . F/ N3 _5 `8 q, T5 X
21.         Count ++;
    ; X6 i, W& Y* l0 p5 E
22.     }
    
23. 
    + f: C2 ^8 S* C4 J: I8 h& o1 e
24. 
    ( t; _- d" q0 r( `7 U! J( z- S
25.     delay_us(20000);
    
26. }

复制代码

    往PWM比较寄存器设置948即为设置38KPWM波，也可在初始化时固定948，在此函数内启停定时器即可；

    至此，自学习功能的全部思路已实现，通过对各个不同类型的红外遥控进行功能测试，均成功。

     PS:查看很多资料发现很多红外解码未判断低电平时间，个人感觉不是很好，应该是不仅高电平时间得符合，低电平时间也应该符合。

    自己写了一个小函数验证了一下，这个函数只是验证，未经仔细推敲，还可优化，仅供参考这一思想。

    误差设计：±200us(拍脑袋值)

1. void InFraredDataDeal(void)
   
2. {
   1 L, A- z$ W% w& |6 a
3. uint32_t DataBuff = 0;
   
4. uint16_t Count = 0;
   
5. 
   
6. 
   4 d2 M- d$ B2 |  v7 y6 `
7. if(gsInfrared.State == END_STATE)
   
8.     {
   
9.         gsInfraredData.State = 0;
   
10. 
    
11. 
    4 U- I0 x9 M  X9 ]# e& {0 n
12. do
    9 g; P$ A8 ]5 _% t' \$ J' h2 T
13.         {
    
14. switch(gsInfraredData.State)
    
15.             {
    
16. case 0:   //引导码识别
    
17.             {
    . o  N( {1 X( n" L) e7 O6 s
18. 
    
19. 
    $ N* y% O! e  s' ~. L/ b/ }, S
20. if(gsInfrared.KeepTime[0] >= 8800 && gsInfrared.KeepTime[0] <= 9200 && gsInfrared.BitValue[0] == 0)
    
21.                 {
    
22. if(gsInfrared.KeepTime[1] >= 4300 && gsInfrared.KeepTime[1] <= 4700 && gsInfrared.BitValue[1] == 1)
    
23.                     {
    
24. if(gsInfrared.KeepTime[2] >= 360 && gsInfrared.KeepTime[2] <= 760 && gsInfrared.BitValue[2] == 0)
    
25.                         {
    4 M' \# F3 }" G1 S! I  y
26.                             Count = 3;
    4 q$ j0 c9 T3 b) G* X5 P
27.                             gsInfraredData.State = 1;
    
28.                         }
    
29.                     }
    ; H3 W* G+ c- Y5 h6 {2 X6 F
30. else if(gsInfrared.KeepTime[1] >= 2300 && gsInfrared.KeepTime[1] <= 2700 && gsInfrared.BitValue[1] == 1)
    " q2 R; e/ r. L1 c" Q1 C/ W- Y, n% J3 R
31.                     {
    
32. if(gsInfrared.KeepTime[2] >= 360 && gsInfrared.KeepTime[2] <= 760 && gsInfrared.BitValue[2] == 0)
    , ^" j* C* U8 R+ a! s6 {. L0 V
33.                         {
    
34.                             gsInfraredData.ReDataCount ++;
    
35.                             gsInfraredData.State = 3;
    
36.                         }
    5 Z/ I2 l- x3 V" q" ~- E% z
37.                     }
    
38. else
    
39.                     {
    
40.                         gsInfraredData.State = 3;
    0 d, E7 _1 f( o$ Q" ~1 e1 x# K
41.                     }
    9 n$ m' h/ o3 T2 |! z# R* B
42. 
    
43. 
    * K6 U* N5 _; I( X
44.                 }
    
45. else
    7 I+ o$ R* [# e, h( G, T. u
46.                 {
    
47.                     gsInfraredData.State = 3;
    
48.                 }
    / d+ ^2 H; z/ y) s, c& _
49. 
    ! A$ q! _  k" G0 A3 Y  W
50. 
    - b% N4 Z( R/ l! t
51. 
    . p' n' |: }" b" l6 [% C
52. 
    
53.             }
    
54. break;
      ~; a- p- l+ |2 E- R& }
55. 
    ) |4 B) E" R4 _; c6 j% U8 c( ]
56. 
    ; O# v5 H4 y3 |6 \! @/ L; G1 n
57. 
    
58. 
    ! ]. h0 q8 ]& q8 U& ^2 s7 `) a3 V
59. case 1:   //数据解析
    
60.             {
    
61. 
    
62. 
    
63. if(gsInfrared.KeepTime[Count + 1] >= 360 && gsInfrared.KeepTime[Count + 1] <= 760 && gsInfrared.BitValue[Count + 1] == 0)
    / p5 z2 R/ W. X/ J3 Z# U
64.                 {
    + q3 T0 N/ l# v' p( T: z
65. 
    
66. 
    ' m+ M/ K6 J' {' p5 I+ ?
67. if(gsInfrared.BitValue[Count] == 1)
    
68.                     {
    
69. if(gsInfrared.KeepTime[Count] >= 1480 && gsInfrared.KeepTime[Count] <= 1880)
    
70.                         {
    
71.                             DataBuff <<= 1;
    " t! A4 s# `) p3 F9 \2 P+ `
72.                             DataBuff |= 1;
    - @, Q7 I4 h) o
73.                         }
    9 I$ ~; g- E! R; n" ^
74. else if(gsInfrared.KeepTime[Count] >= 360 && gsInfrared.KeepTime[Count] <= 760 && gsInfrared.BitValue[Count] == 1)
    4 c8 b  T- {: h& J- I( M, ~) ]; E
75.                         {
    # P6 C) r, x) Z1 X. N$ R- {- n% }
76.                             DataBuff <<= 1;
    
77.                             DataBuff |= 0;
    4 s. `4 E: J9 v8 H) C: K7 d6 O
78.                         }
    # a+ M2 x9 I: L, L
79. else
    1 I; ]4 m, e; z' p6 ]
80.                         {
      Q; h* b8 q1 v6 b
81.                             gsInfraredData.State = 3;
    
82.                         }
    . c# W( o- x8 v( X, [8 g
83.                     }
    
84.                 }
    
85. 
    
86. 
    
87. if(Count < gsInfrared.SampleCount)
    % d9 Q/ X; ?5 Z  n  P* Z
88.                 {
    
89.                     Count += 2;
    
90.                 }
    : z2 b5 N* s9 T
91. else
    4 m7 z& X* E( F: l7 \& l* Y
92.                 {
    
93.                     gsInfraredData.State = 2;
    + e! ]; i" b; r9 a5 j6 K
94.                 }
    
95. 
    
96. 
      u! T: d' ?$ ], L
97.             }
    
98. break;
    ( e. d0 j: m' e
99. 
    
100. 
     ( P. X# G' `$ @$ |5 r
101. case 2:   //成功解析
     
102.             {
     % M$ D; a* u' f) {" `
103.                 gsInfraredData.Data = DataBuff;
     
104.                 gsInfraredData.State = 3;
     
105. 
     6 F* @$ a/ t" }
106. 
     " d7 k* m, |& u, r' h! h% I
107.             }
     
108. break;
     
109. 
     & Q  G7 g) q- }/ R6 E9 x; i
110. 
     5 w8 T  \7 [0 r8 U! H8 n
111. default:
     $ D! a( n& P) S/ {6 l( r# Y1 `
112.             {
       R0 \) U0 z2 @  s7 s) v; ~
113.                 gsInfraredData.State = 3;   //解析结束
     3 y; r5 {  p8 q3 c* `+ B
114. 
     , s: ]. w  [2 E
115. 
     
116.             }
     
117. break;
     " H) n- R, w( \; r9 ~& J) |  c
118.             }
     5 G3 P* F* K, K; [
119. 
     
120. 
     7 t; ]/ h3 j0 q! k" v
121.         }
     
122. while(gsInfraredData.State != 3);
     & P3 B& `' N8 ^" [2 p) H
123. 
     
124. 
     
125.         gsInfrared.State = NONE_STATE;
     
126.         gsInfrared.SampleCount = 0;
     
127.     }
     
128. 
     
129. 
     / g8 a/ f2 N& M7 ~" H
130. }

复制代码

    解析的话一般高位在前，所以左移，经测试帧格式为：引导码+用户码+用户码反码+命令码+命令码反码，能成功解析数据！解析的话根据具体协议，具体分析。

& C! A- G) ^- @4 Z, y- M5 b- ~: S转载自：树荫下的阳光