时间码发生器通过两条线与MCU相连，一条是地，一条是信号线用于传输数据。信号传输使用差分曼彻斯特编码。电平±1.5V, 信号传输的速率960Hz 到 2400Hz 变化，需要软件自动适配。 时间码固定为80bit数据（bit0~bit79）， 其中bit64~bit79 为同步码，固定为0011 1111 1111 1101。 部分波形如下图，

8 o3 ^" I; L5 U; p
+ B5 r, o! _3 i4 v- _
8 b: ]' b6 K" c6 }" P& x) f实现原理，

3 S/ r) ]0 z8 z1.  EXTI  Rising/Falling 中断+定时器方式测量100次波形脉冲宽度，通过排序算法找到合适的值确定为定时器周期值Period
% n+ ^' ^9 y/ S
# ^4 I8 h- O1 u2.  继续用EXTI  Rising/Falling 中断+定时器方式接收时间码0101值， EXTI  Rising/Falling 中断时，修正定时器中断周期为Period/2。
) u. F! e3 C' b' }2 ~7 }8 G4 X% S
产生定时器中断之后，取Pin 值保存，修正定时器中断周期为Period
4 j) {/ e% S) `
3.  解析差分曼切斯特编码，查找同步码

流程图，

关键过程代码，
8 C2 l3 }+ U2 s/ D
1. EXIT 中断处理

1. struct LtcInput_s LtcInput = {
   2 H' g  y. u- `, x
2.     .tim = {0},
   # G' N# Y/ c9 h& K0 j
3.     .tim_count = 0,
   
4.     .period = 0xffff,
   
5. };
   
6. 
   4 q: n: U2 F: ]- w2 g8 A, o
7. static uint16_t parse_tim_of_ltc_input_get_period(void)
   * r8 }. S* ~7 i
8. {
   6 r; c9 ~) ]$ ?9 ?  F5 ]: k0 s
9.     for (int i = 0; i < LTC_INPUT_BUF_SIZE; ++i) {
   9 f5 Q" V( p( s! h: R. B5 }
10.         for (int j = i; j < LTC_INPUT_BUF_SIZE; ++j) {
    4 O% \" _  p2 t. _( ^
11.             if(LtcInput.tim<i> > LtcInput.tim[j]) {</i>
    4 M5 h0 u/ G# _+ A
12. <span style="font-style: italic;">                uint16_t tmp = LtcInput.tim;
    
13.                 LtcInput.tim<i style="font-style: italic;"> = LtcInput.tim[j];
    
14.                 LtcInput.tim[j] = tmp;
    
15.             </i><span style="font-style: normal;">}
    
16.         }
    . r2 `+ Q5 P" u8 |: m! g) o
17.     }
    # `7 ]6 y7 L$ Y3 w1 a
18.     uint16_t period = LtcInput.tim[10];
    
19.     return period;
    4 W% y% Y2 k1 F
20. }
    
21. 
    
22. void ltc_input_timer_restart(int period)
    
23. {
    6 H7 E  s9 Q5 v
24. 
    0 b$ t' [* u) _7 h9 Z0 |
25.   htim3.Instance->SR = 0;
    9 W) C, ~* k. I' T# K$ L1 O" Q
26. htim3.Instance->ARR = period;
    ! f  |+ A5 l; B
27. htim3.Instance->CNT = 0;
      v1 H! f" i; x  w
28. 
    % q- S& v2 {: q" i0 z5 {9 x
29. }
    6 h& k( m$ Z3 K
30. 
    ! _* K( Q/ ?8 D9 e
31. void ltc_input_pin_callback(void)
    
32. {
    . u) {+ Q) ]9 }% T
33.     // HAL_TIM_Base_Stop_IT(&htim3);
    & M; Z+ ~  x  U+ g/ K/ ^3 M
34.     if(LtcInput.tim_count >= LTC_INPUT_BUF_SIZE) {
    - |8 e1 ?- r  j/ w) r
35.         ltc_input_timer_restart(LtcInput.period/2);
    # W/ n7 `* P7 y* o
36.     } else {
    
37.         LtcInput.tim[LtcInput.tim_count] = htim3.Instance->CNT;
    9 N$ e8 `/ m9 }( f7 J
38.         LtcInput.tim_count++;
    
39.         if(LtcInput.tim_count >= LTC_INPUT_BUF_SIZE) {
    
40.             LtcInput.period = parse_tim_of_ltc_input_get_period();
    
41.         }
    2 _. q2 j$ T2 k, x# w" `& r/ `
42.         ltc_input_timer_restart(0xffff);
    
43.     }
    
44. }</span></span>

复制代码

2. 定时器处理
) z+ |( C  Z" f. d

1. /**
   
2.   * @brief This function handles TIM3 global interrupt.
   
3.   */
   
4. void TIM3_IRQHandler(void)
   
5. {
   ; H7 f5 T4 q  @& g# B3 ^$ r, V
6.   /* USER CODE BEGIN TIM3_IRQn 0 */
   
7. 
   ' i1 \7 q0 |0 i0 E
8.   /* USER CODE END TIM3_IRQn 0 */
   6 u( o# _' g/ Y6 c5 [/ G
9.   HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
   
10.   htim3.Instance->SR = 0;
    
11.   htim3.Instance->ARR = LtcInput.period;
    - U7 d) ~! T  f" r
12.   htim3.Instance->CNT = 0;
    
13.   ltc_input_timer_callback();
    
14. 
    ) b8 ~1 y' U& y- N' O! n
15.   /* USER CODE END TIM3_IRQn 1 */
    - R" v* V7 d" Y
16. }
    3 w8 t1 x* n8 _4 y; D
17. 
    
18. char ltc_input_timer_callback(void)
      r# }1 w1 r& X2 j' G
19. {
    $ U4 Y7 |* g; n# a5 c% i
20.     GPIO_PinState status;
    
21.     unsigned char x, y;
    . K' c( h! _. w; W  t/ h; |
22. 
    
23.     status = HAL_GPIO_ReadPin(LTC_INPUT_GPIO_Port, LTC_INPUT_Pin);
    
24.     //status = GPIO_ReadInputDataBit(LTC_PORT, LTC_PIN);
    
25.     //HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
    & }4 y' Y: v0 ]: ~4 p  {
26. 
    
27.     //GPIO_WriteBit(TEST_PORT, TEST_PIN, status);
      d- J6 N8 M0 A* N4 z4 ?2 i+ n& ?* T
28.     //GPIO_WriteBit(TEST_PORT, TEST_PIN, SET);
    - ]" N5 B; [1 \' t
29.     //move_right_linear_timecode_raw(linear_timecode_raw, sizeof(linear_timecode_raw));
    
30. 
    " K! X$ ]' o* J- G" h
31.     x = linear_timecode_count /8;
    
32.     y = linear_timecode_count %8;
    5 a' I6 k9 R3 |# a  K; q/ S
33. 
    
34.     //buf[linear_timecode_count] = status;
    , p4 r, Y' ~0 Y5 z7 e1 ?" G% }
35.     linear_timecode_raw[x] &= ~(1 << y);
    1 d7 T  m- L& v
36. 
    
37.     if(status != GPIO_PIN_RESET) {
    
38.         linear_timecode_raw[x] |= (1 << y);
      W8 ?# ?3 n# j7 g9 _1 L
39.     }
    8 c+ e1 U2 N4 M8 u8 a
40. 
    9 d* {6 J8 [) G
41.     linear_timecode_count ++;
    ( I7 W9 x7 |8 r1 R8 V, g
42. 
    
43.     if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
    
44.         if(linear_timecode_count >= sizeof(linear_timecode_raw) * 8) {
    : z6 K: K( a6 s' v& E7 }1 `- j2 h
45.             linear_timecode_count =0;
    
46.             memcpy(linear_timecode_raw_ready, linear_timecode_raw, sizeof(linear_timecode_raw));
    
47.             linear_timecode_ready = 1;
    ) y4 i, h& `2 p, l, o
48.         }
    
49.     } else {
    5 B% R4 U' {: Z9 u0 _' y# w
50.         if(offset_bits > 0) {
    
51.             //skip offset_bits
    $ l- P% u/ E& `1 [$ ]9 u
52.             //If offset < linear_timecode_count, adjust the offset to the next frame.
    5 U! d1 }8 Y$ m$ K
53.             //Next time, when count = offset, the counter is cleared. From then on, each frame starts from scratch.
    
54.             if(linear_timecode_count > offset_bits) {
    
55.                  offset_bits += 160;
    # H' q9 l3 _& o$ a0 a
56.             } else if(linear_timecode_count == offset_bits) {
    
57.                 offset_bits = 0;
    
58.                 linear_timecode_count = 0;
    
59.             }
    " ^8 j+ e9 o% l! F
60.         } else {
    ! x" r! ~7 S/ P8 y& \. A+ R5 I) M
61.             if(linear_timecode_count >= sizeof(linear_timecode_raw) * 8 / 2) {
    ; d. M7 `! q- _5 ]( V+ _4 k: B4 p
62.                 linear_timecode_count =0;
    2 [! N1 ~5 L0 q7 o0 C! j' {
63.                 memcpy(linear_timecode_raw_ready, linear_timecode_raw, sizeof(linear_timecode_raw) / 2);
    
64.                 linear_timecode_ready = 1;
    
65.             }
    
66.         }
    
67.     }
    
68.     return 0;
    & d0 p5 ~& L) p  M
69. }

复制代码

4 Q7 \# s5 n9 b' p6 h; g3.  差分曼切斯特码解码
1 f8 B" g' y; G. `1 ]; k0 }

1. 
   ' K* X- [( P. {$ {$ {
2. unsigned char r_mask[] = {0x0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
   - U) }  H. _- M' X* Y
3. unsigned char l_mask[] = {0x0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
   
4. 
   
5. static void move_right_linear_timecode_raw_7bits(unsigned char *raw, unsigned char nbytes, unsigned char nbits)
   % |4 q6 q# J# j' {" C
6. {
   ( B% u! v: b# }4 N& `
7.     unsigned char i;
   + F9 S. _1 _( o) a7 v
8.     unsigned char tmp;
   
9. 
   
10.     if((nbits < 1) || (nbits > 7)) {
    7 l  N2 g$ F8 J, w
11.         return;
    0 o- a1 ]5 h: g1 E! [, i6 v( Q) ~
12.     }
    ) t( _& j& h: a" {# g# ^+ o
13. 
    
14.     for(i=0; i<nbytes - 1; i++) {
    
15.         tmp = raw[i+1] & r_mask[nbits];
    7 w+ u! l; ]% ]' _* R+ L
16.         tmp <<= (8-nbits);
    . D- L( q- n4 u/ I+ Z* m
17.         raw<span style="font-style: italic;"><span style="font-style: normal;"> >>= nbits;
    . O$ Q0 ~6 ~" G' [/ Y
18.         raw</span><span style="font-style: normal;"> += tmp;
    2 Q4 Q1 ]0 n6 b, G- J. \1 i1 n  A
19.     }
    ' R% H$ d' Z' @0 n& g. M  z, Q
20.     raw</span><span style="font-style: normal;"> >>= nbits;
    $ e( Q, h! D9 u1 p& W/ K4 ~9 O* z
21. }
    
22. 
    / n4 p/ a/ U. Y3 J
23. static void move_left_linear_timecode_raw_7bits(unsigned char *raw, unsigned char nbytes, unsigned char nbits)
    ! t& m; w) y$ `6 k! V" \  [
24. {
    + x4 K: B: g. N$ r6 Y5 K
25.     unsigned char i;
    
26.     unsigned char tmp;
    4 Z- o* P9 q  b3 s$ ?3 B* X6 W
27. 
    
28.     if((nbits < 1) || (nbits > 7)) {
    
29.         return;
    : t4 a# i/ @9 J: J
30.     }
    
31. 
    
32.     for(i=0; i<nbytes - 1; i++) {
    
33.         //prev_bit = raw</span><span style="font-style: normal;"> & 0x80;
    
34.         tmp = raw[nbytes - i - 2] & l_mask[nbits];
    
35.         raw[nbytes - i -1] <<= nbits;
    , R; Z8 p5 X! {1 K4 w
36.         tmp >>= (8-nbits);
    
37.         raw[nbytes - i -1] += tmp;
    
38.     }
    ; d: \1 H# Y+ b- K+ L! g
39.     raw[0] <<= nbits;
    / C( K5 U2 U$ n9 Z( `9 K
40. }
    
41. 
    
42. static void move_right_linear_timecode_raw_nbits(unsigned char *raw, unsigned char nbytes, unsigned short nbits)
    
43. {
    
44.     unsigned char x, y;
    
45. 
    
46.     x = nbits / 8;
    & q) k) Y9 m8 W& ?: G( K% I
47.     y = nbits % 8;
    
48. 
    , f" n5 _+ r% d$ L: N
49.     if(x > 0) {
    : V. E2 q& L2 o; m/ [
50.         for (int i = 0; i < nbytes ; i++) {
    , I) |. h; B0 K
51.             raw</span><span style="font-style: normal;"> = raw[x+i];
    
52.         }
    $ ?7 @4 L# N# w/ w9 k9 {
53.     }
    , @0 F0 D. L- L. q8 X4 O
54.     move_right_linear_timecode_raw_7bits(raw, nbytes, y);
    ' b7 k% k  b' C( P- h
55. }
    * @2 g6 ~3 D  ]# r2 {, G
56. 
    
57. 
    
58. static void move_left_linear_timecode_raw_nbits(unsigned char *raw, unsigned char nbytes, unsigned short nbits)
    $ `$ F5 D" e- ?
59. {
    " C( L* o( y9 S' ?$ ^& P) O
60.     unsigned char x, y;
    
61. 
    
62.     x = nbits / 8;
    ) v9 k6 p" e/ A6 e
63.     y = nbits % 8;
    7 E! F$ B9 L& R# }7 H- d
64. 
    
65.     if(x > 0) {
    
66.         for (int i = 0; i < nbytes ; i++) {
    - ~. Z4 \4 u% ?/ B" H/ d, R8 M1 {
67.             raw[nbytes-i-1] = raw[nbytes-i-1-x];
    ' A# X% v, e  h/ N- c
68.         }
    
69.     }
    
70.     move_left_linear_timecode_raw_7bits(raw, nbytes, y);
    
71. }
    
72. 
    0 }5 I$ Z% ?$ F
73. unsigned char get_bit_linear_timecode_raw(unsigned char index)
    / K( I4 @8 v7 R
74. {
    
75.     unsigned char x = index/8;
    
76.     unsigned char y = index%8;
    0 Z% v" Q0 W3 H( k0 X& j& W" }
77. 
    ! h. c% ^: ~/ v  ]# m
78.     if(linear_timecode_raw[x] & (1 <<y))
    ' o3 C! N# ^  s% P6 T$ T& S3 z
79.         return 1;
    : _. Q& S: h+ l% h! I+ ?
80.     else
    & @% M6 P; T1 v* n! ^, s: @
81.         return 0;
    5 L+ r9 i5 n& m- k' R, O3 H
82. }
    
83. 
    - m5 d- W/ [) u' I2 g
84. static void parse_differential_manchester_code(unsigned char *src,  unsigned char *dst, unsigned char dst_size)
    
85. {
    
86.     unsigned char i, j;
    - R2 I' G0 U: a: d
87.     unsigned short tmp, tmp2;
    
88. 
    
89.     for(i=0; i<dst_size; i++) {
    7 y. G/ }" \# K0 K
90. 
    
91.         tmp = (src[i*2 +1] << 8) + src[i*2];
    
92.         dst</span><span style="font-style: normal;"> = 0;
    
93.         for(j=0; j<8; j++) {
    
94.             tmp2 = tmp & (3 << j*2);
    0 }+ M' Y* u% w$ C7 e* I8 Y1 s; J
95.             tmp2 >>= j*2;
    * }' d" V- N1 _! X0 A: }7 @
96.             if((0 != tmp2) && (3 != tmp2)) {
    3 n0 s5 `% D8 \# u
97.                 dst</span><span style="font-style: normal;"> |= (1<<j);
    . Z& H2 K' J! z2 s# e, }- Q% {
98.             }
    1 g! ]8 A5 k% G
99.         }
    - ?, i: K" W* ?
100.     }
     
101. }
     
102. 
     
103. static char find_sync_code(unsigned char *src, unsigned char len, unsigned char *dst, unsigned char *valid_len)
     
104. {
     
105.     const unsigned short sync_code = 0xFCBF;
     
106.     unsigned char i;
       X+ r( z9 c2 T, W
107.     unsigned short tmp;
     
108.     char ret=-1;
     
109. 
     6 F5 c, T4 m/ c
110.     for (i=0; i<len-8; i++) {
     
111.         tmp = (src[i+8] << 8) + src[i+9];
     
112.         if (tmp == sync_code) {
     
113.             ret =0;
     
114.             *valid_len = len - i;
     * b/ u0 i. a$ J6 G  h: @9 \
115.             memcpy(dst, &src</span><span style="font-style: normal;">, 10);   //10Bytes equals 80bits
     2 ]* d9 k0 U, z1 X0 ~
116.             break;
     
117.         }
     + Y" v3 Y, h0 `& ?+ U
118.     }
     
119. 
       K; ?; |8 K4 A3 `# w/ q& g
120.     return ret;
     
121. 
     
122. }
     8 m3 B6 q" Y" B5 \9 R( i! _* o
123. 
     
124. unsigned char ltc_dst_code[40][10]= {0};
     
125. unsigned char ltc_dst_code_count = 0;
     
126. unsigned char ltc_code_valid_len=0;
     
127. unsigned char ltc_code[20] = {0};
     
128. unsigned char raw_ready[60] = {0};
     1 l+ v- {7 p# a! @* |
129. unsigned short offset_bits = 0;
     % F! b% s' y( y, f2 W# W/ p2 T
130. unsigned short ltc_remain_bits = 0;
     . V6 ~. d1 J; d* a
131. unsigned char sec_ltc_code[20] = {0};
     2 d: X/ U: Q& `! x" L: N
132. unsigned char ltc_dst_code_cur[10]= {0};
     & u! q* u: g& |0 j
133. unsigned char new_frame =0;
     
134. 
     
135. 
     
136. void parse_linear_timecode_raw()
     
137. {
     
138.     unsigned char tmp;
     
139.     unsigned char raw_mv_right_bits = 0;
     + r2 ?3 R7 q( X9 y5 g/ Y3 H
140. 
     ! J+ z! H" `) K
141.     if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
     
142.         isjam = 0;
     8 Y7 E1 Y$ {  n
143.         memcpy(raw_ready, linear_timecode_raw_ready, sizeof(linear_timecode_raw_ready));
     
144.         tmp = raw_ready[0] & 0x03;
     
145.         while((0 != tmp) && (3 != tmp)) {
     
146.             move_right_linear_timecode_raw_nbits(raw_ready, sizeof(raw_ready), 1);
     6 i& [5 l- z0 F, {5 [  B
147.             raw_mv_right_bits ++;
     2 K( G& Q- n! U/ ], x9 A2 J& s
148.             tmp = raw_ready[0] & 0x03;
     
149.         }
     
150. 
     4 {6 }* n/ D, U( T# S- A- R
151.         for (int i = 0; i < sizeof(linear_timecode_raw_ready)*8; ++i) {
     & \1 v" w+ a: a
152.             memset(ltc_code, 0 , sizeof(ltc_code));
     
153.             parse_differential_manchester_code(raw_ready,  ltc_code, sizeof(ltc_code));
     / P0 p( R2 p# y
154.             //0xFCBF;
     
155.             if((ltc_code[8] == 0xFC)&&(ltc_code[9]==0xBF)) {
     : a9 z7 `. o4 M7 |& A! W* A
156.                 linear_timecode_status = !LTC_STATUS_NEED_FIND_SYNC;
     8 h$ T+ K4 _: C5 A( n) P* s$ E
157.                 offset_bits = raw_mv_right_bits;
     . H2 l+ W7 T( N2 A; n
158.                 break;
     
159.             }
     
160.             move_right_linear_timecode_raw_nbits(raw_ready, sizeof(raw_ready), 1);
     8 O- ^/ T3 a6 Z- i0 e4 n& X3 u9 z
161.             raw_mv_right_bits ++;
     
162.         }
     , h4 N6 V( I$ W8 v  [
163. 
     
164.         if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
     
165.             LtcInput.tim_count = 0;     //reflesh tim2 period
     
166.         }
     
167. 
     
168.     } else {
     7 F: G! u; n$ @+ u6 N$ G- @
169.         isjam = 1;
     
170.         memcpy(ltc_code, linear_timecode_raw_ready, sizeof(ltc_code));
     ( N' D/ k* ~5 ^, y7 X
171.         parse_differential_manchester_code(ltc_code,  ltc_dst_code_cur, sizeof(ltc_dst_code_cur));
     
172.         if((ltc_dst_code_cur[8] != 0xFC)||(ltc_dst_code_cur[9]!=0xBF)) {
     ) A  M# s; z; s0 ^+ ~
173.             linear_timecode_status = LTC_STATUS_NEED_FIND_SYNC;
     
174.             LtcInput.tim_count = 0;     //reflesh tim2 period
     ' m( f5 K/ F6 v' s! v; k  v
175.         } else {
     
176.             new_frame =1;
     - e4 E1 @( J; U9 S/ h- J1 \
177.         }
     
178.     }
     . I3 F  \5 @2 ]5 D& M  _
179. }
     ! k5 B* G7 v% F! o0 E
180. </span></span>

复制代码

总结以及调试过程中发现的问题。
- W9 b& w# q' ^
# s. a6 m5 q# I, Q1. 测量周期，比较顺利， 56MHz ， 测量出脉冲周期202 us
* `' Z/ ?2 }/ R& Q! ~, O& R$ K' n
" v- q# K6 l2 F9 [1 d; @3 V

2. 采样过程中，发现定时器中断，在修正过程中， 出现中断异常，增加调试口翻转看波形
8 O6 ~5 R/ ~% }, l
异常1， 中断回调，里面调用HAL_TIM_xxx ,  导致反复进入定时器中断,

% N% o6 x1 E+ ~, t异常2， 定时器停止-> 修改周期 -> 定时器启动，每次启动都会中断一下，启动前清中断标志也不行

5 d& |# `3 t! w; L5 C4 h! z

解决办法，通修改 TIM中断处理程序，直接修改寄存器。 中间不停止，最终得到正确的波形
# O$ y- O6 h) J) q& B

1. void TIM3_IRQHandler(void)
   
2. {
   
3.   /* USER CODE BEGIN TIM3_IRQn 0 */
   
4. 
   1 z& o/ v$ _* r. E, q% c, X( j) p
5.   /* USER CODE END TIM3_IRQn 0 */
   6 L# J2 z) q0 Y9 ~. t; N
6.   HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
   
7.   htim3.Instance->SR = 0;
   
8.   htim3.Instance->ARR = LtcInput.period;
   $ l* q. [$ J6 a6 v' r& R; ]
9.   htim3.Instance->CNT = 0;
   " I! N5 I$ @- O! ~
10.   ltc_input_timer_callback();
    
11. 
    1 {, w" M8 {, h4 Z5 M. A
12.   /* USER CODE END TIM3_IRQn 1 */
    
13. }

复制代码

9 e1 g; {- d# q# ]  \6 L