时间码发生器通过两条线与MCU相连，一条是地，一条是信号线用于传输数据。信号传输使用差分曼彻斯特编码。电平±1.5V, 信号传输的速率960Hz 到 2400Hz 变化，需要软件自动适配。 时间码固定为80bit数据（bit0~bit79）， 其中bit64~bit79 为同步码，固定为0011 1111 1111 1101。 部分波形如下图，
1 h3 @/ a7 V( F& I0 Y
4 P4 y1 [& T& Y8 ]% x* l

4 ~5 |' o3 i9 P" z: M7 I* i( e. K7 o

实现原理，

1.  EXTI  Rising/Falling 中断+定时器方式测量100次波形脉冲宽度，通过排序算法找到合适的值确定为定时器周期值Period

- z# N* c) a) _2.  继续用EXTI  Rising/Falling 中断+定时器方式接收时间码0101值， EXTI  Rising/Falling 中断时，修正定时器中断周期为Period/2。
3 C! j) g1 E" O' ]
产生定时器中断之后，取Pin 值保存，修正定时器中断周期为Period

7 J+ Z" W% ~1 @! c2 Z2 j7 Y3.  解析差分曼切斯特编码，查找同步码
0 G4 Q) {5 m( L# L! b
流程图，
# I/ b. _* l& f! E' {! K; A
# [& p4 m7 Y3 _9 p) X7 H

关键过程代码，

) |4 Z/ ^1 ^; L1 D( z1. EXIT 中断处理

: [+ K! f- K- o9 v

1. struct LtcInput_s LtcInput = {
   ( `; S5 i. F/ @2 M) `" r
2.     .tim = {0},
   
3.     .tim_count = 0,
   
4.     .period = 0xffff,
   
5. };
   
6. 
   
7. static uint16_t parse_tim_of_ltc_input_get_period(void)
   
8. {
   & K2 z& d5 [- t% h, f/ w2 Y+ g
9.     for (int i = 0; i < LTC_INPUT_BUF_SIZE; ++i) {
   2 O5 A6 m( @" w; a& f- n6 a
10.         for (int j = i; j < LTC_INPUT_BUF_SIZE; ++j) {
    ) n1 c& K) U+ C* U
11.             if(LtcInput.tim<i> > LtcInput.tim[j]) {</i>
    . U8 E; a4 O% O' v+ X& q6 @; p. [
12. <span style="font-style: italic;">                uint16_t tmp = LtcInput.tim;
    + @! [8 X; k4 F3 O! r/ m) T9 X
13.                 LtcInput.tim<i style="font-style: italic;"> = LtcInput.tim[j];
    
14.                 LtcInput.tim[j] = tmp;
    
15.             </i><span style="font-style: normal;">}
    9 N1 E& e* H( z( y/ K
16.         }
    
17.     }
    ! x% W& {/ K9 i5 ?
18.     uint16_t period = LtcInput.tim[10];
    7 V) Z6 {: t' k9 E* s1 [; t3 ~6 ^
19.     return period;
    
20. }
    % v$ T; l# ^+ O# C: n( L) ?6 H
21. 
    
22. void ltc_input_timer_restart(int period)
    
23. {
    
24. 
    
25.   htim3.Instance->SR = 0;
    
26. htim3.Instance->ARR = period;
    5 Y! Z) m" e9 z; }- X
27. htim3.Instance->CNT = 0;
    # t: b" y2 Z" M: r1 E" r
28. 
    ! c: I) b" o9 f
29. }
    $ ?# z1 l/ @+ x3 F4 S  V1 a. ~3 o7 r
30. 
    
31. void ltc_input_pin_callback(void)
    ; E# g) A& L( q
32. {
    
33.     // HAL_TIM_Base_Stop_IT(&htim3);
    $ s; M" b1 h! M
34.     if(LtcInput.tim_count >= LTC_INPUT_BUF_SIZE) {
    . Q0 Q+ k; k2 V$ `. w6 s! d2 D
35.         ltc_input_timer_restart(LtcInput.period/2);
    
36.     } else {
    
37.         LtcInput.tim[LtcInput.tim_count] = htim3.Instance->CNT;
    
38.         LtcInput.tim_count++;
    
39.         if(LtcInput.tim_count >= LTC_INPUT_BUF_SIZE) {
    
40.             LtcInput.period = parse_tim_of_ltc_input_get_period();
    
41.         }
    
42.         ltc_input_timer_restart(0xffff);
    
43.     }
    
44. }</span></span>

复制代码

2. 定时器处理
6 N9 |+ [( O" y# o7 J

1. /**
   + D5 D7 \) h6 L$ V
2.   * @brief This function handles TIM3 global interrupt.
   7 \1 Q4 _- E* |% [
3.   */
   
4. void TIM3_IRQHandler(void)
   
5. {
   ; V& q" G( U6 \. \" w
6.   /* USER CODE BEGIN TIM3_IRQn 0 */
   # v5 S3 w8 R8 v- L* Z" K7 y4 M
7. 
   
8.   /* USER CODE END TIM3_IRQn 0 */
   
9.   HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
   ( x4 I5 y2 O+ R( ^
10.   htim3.Instance->SR = 0;
    
11.   htim3.Instance->ARR = LtcInput.period;
    & M* o8 q( Z  x( u4 D
12.   htim3.Instance->CNT = 0;
    
13.   ltc_input_timer_callback();
    * b2 H; z( X; T/ O* v
14. 
    
15.   /* USER CODE END TIM3_IRQn 1 */
    / |4 R0 [3 l. Y
16. }
    % c4 e* ?2 }8 V% m
17. 
    . d1 R. `/ w) [) q1 F5 O
18. char ltc_input_timer_callback(void)
    7 E& ~+ S8 y0 @: S% ?: ~5 p! |0 {7 [
19. {
    
20.     GPIO_PinState status;
    
21.     unsigned char x, y;
    
22. 
    : A8 l/ J! f0 x6 n# S4 J
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);
    & E' `. Z$ ?( X
26. 
      s+ a2 I/ b& Z! D0 ]% u1 q) |' E, @% d1 @
27.     //GPIO_WriteBit(TEST_PORT, TEST_PIN, status);
    % p. S+ p1 v. o4 v. p# E: _
28.     //GPIO_WriteBit(TEST_PORT, TEST_PIN, SET);
    
29.     //move_right_linear_timecode_raw(linear_timecode_raw, sizeof(linear_timecode_raw));
    6 `, a1 o; k1 _" s% G, S3 s. p
30. 
    1 L6 r6 \' Q7 W
31.     x = linear_timecode_count /8;
    * H5 E3 q4 n/ a  ~( Y. @
32.     y = linear_timecode_count %8;
    ! m4 U% h5 i+ x: h- y) o, F# N
33. 
    
34.     //buf[linear_timecode_count] = status;
    
35.     linear_timecode_raw[x] &= ~(1 << y);
    
36. 
    
37.     if(status != GPIO_PIN_RESET) {
    % d  I$ t! L* g3 Z  k$ T1 S+ |
38.         linear_timecode_raw[x] |= (1 << y);
    3 d% s5 y/ h; ~5 N! D0 S; n
39.     }
    
40. 
    
41.     linear_timecode_count ++;
    
42. 
    7 M1 ^, B! j6 Z& W( R
43.     if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
    
44.         if(linear_timecode_count >= sizeof(linear_timecode_raw) * 8) {
    
45.             linear_timecode_count =0;
    
46.             memcpy(linear_timecode_raw_ready, linear_timecode_raw, sizeof(linear_timecode_raw));
    
47.             linear_timecode_ready = 1;
      {9 m  s. o9 w: C
48.         }
    
49.     } else {
    
50.         if(offset_bits > 0) {
    
51.             //skip offset_bits
    ) k6 W  K) U) J  L7 c- n/ @9 y
52.             //If offset < linear_timecode_count, adjust the offset to the next frame.
    
53.             //Next time, when count = offset, the counter is cleared. From then on, each frame starts from scratch.
    8 A% w& [: P6 N" f! H/ ~( T
54.             if(linear_timecode_count > offset_bits) {
    
55.                  offset_bits += 160;
    
56.             } else if(linear_timecode_count == offset_bits) {
    
57.                 offset_bits = 0;
    
58.                 linear_timecode_count = 0;
    
59.             }
    2 E) l, u7 R6 g4 k" T6 N
60.         } else {
    & j5 R# L8 n( D! |5 b
61.             if(linear_timecode_count >= sizeof(linear_timecode_raw) * 8 / 2) {
    
62.                 linear_timecode_count =0;
    
63.                 memcpy(linear_timecode_raw_ready, linear_timecode_raw, sizeof(linear_timecode_raw) / 2);
    * U6 j" Y- ~5 B0 R
64.                 linear_timecode_ready = 1;
    
65.             }
    , _& C5 H- t8 m0 l4 E
66.         }
    - {9 O6 p( t1 [; m% d2 _
67.     }
    
68.     return 0;
    
69. }

复制代码

5 D& g( W5 J1 M  C  L3 R# W3 T6 y3.  差分曼切斯特码解码
+ E( j) J# P9 u, c" |3 |% S; T4 I

1. 
   9 k5 P2 T( n- s! e* C% k
2. unsigned char r_mask[] = {0x0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
   
3. unsigned char l_mask[] = {0x0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
   3 f3 o+ D9 K: e! a2 O! v
4. 
   ( t- Y7 T4 M) k3 C7 P9 T
5. static void move_right_linear_timecode_raw_7bits(unsigned char *raw, unsigned char nbytes, unsigned char nbits)
   5 X3 n: }) ?5 Y5 d* }
6. {
   ; @7 N& J" ?3 g$ h) y' S9 `8 q
7.     unsigned char i;
   
8.     unsigned char tmp;
   / g: U. Z9 [# ~
9. 
   
10.     if((nbits < 1) || (nbits > 7)) {
    8 H9 L" B0 K1 i, W, r, ^
11.         return;
    5 j' ?1 r2 q) x# B9 R8 P) s1 Z. j
12.     }
    
13. 
    2 P  @5 q% Z+ o  F8 h/ V1 G# z
14.     for(i=0; i<nbytes - 1; i++) {
    
15.         tmp = raw[i+1] & r_mask[nbits];
    $ p& M) O% y& I7 U9 [% W+ k3 r
16.         tmp <<= (8-nbits);
    ' b  y3 H9 a* [" {1 j8 j# Q: q3 F0 ?7 g
17.         raw<span style="font-style: italic;"><span style="font-style: normal;"> >>= nbits;
    
18.         raw</span><span style="font-style: normal;"> += tmp;
    
19.     }
    
20.     raw</span><span style="font-style: normal;"> >>= nbits;
    
21. }
    
22. 
    ( F; f3 L9 [* C8 n
23. static void move_left_linear_timecode_raw_7bits(unsigned char *raw, unsigned char nbytes, unsigned char nbits)
    4 O9 d" A9 o- {: E$ [; Z
24. {
    4 M+ W% e2 c) i
25.     unsigned char i;
    
26.     unsigned char tmp;
    
27. 
    
28.     if((nbits < 1) || (nbits > 7)) {
    
29.         return;
    
30.     }
    
31. 
    
32.     for(i=0; i<nbytes - 1; i++) {
    0 q3 ~; N3 M9 f- X0 j" t
33.         //prev_bit = raw</span><span style="font-style: normal;"> & 0x80;
    # @1 z- @3 e' ~% M
34.         tmp = raw[nbytes - i - 2] & l_mask[nbits];
    
35.         raw[nbytes - i -1] <<= nbits;
    , \8 D8 `. }2 s$ l( Y: ]. n
36.         tmp >>= (8-nbits);
    
37.         raw[nbytes - i -1] += tmp;
    
38.     }
    ! X: A; c8 d$ N
39.     raw[0] <<= nbits;
    / a& [7 t2 h" S
40. }
    / F, q8 c: J# {1 r
41. 
    6 I# S* @) l+ @; _1 c6 ?( U
42. static void move_right_linear_timecode_raw_nbits(unsigned char *raw, unsigned char nbytes, unsigned short nbits)
    
43. {
    : E! m+ ^. G9 Y
44.     unsigned char x, y;
    
45. 
    - m+ M, k9 L( k+ ~9 I  n5 U, |% O
46.     x = nbits / 8;
    
47.     y = nbits % 8;
    
48. 
    , U- P9 a% O! ^! x  ^6 U
49.     if(x > 0) {
    4 p* v0 K2 N. a
50.         for (int i = 0; i < nbytes ; i++) {
    ! `. c; u/ ?2 S
51.             raw</span><span style="font-style: normal;"> = raw[x+i];
    0 f* e& i& W3 `' I& L( `, W+ f
52.         }
    - b: T. D5 T. Y6 ~
53.     }
    7 q6 V7 Q* o; P. D% e8 y1 |
54.     move_right_linear_timecode_raw_7bits(raw, nbytes, y);
    % Z& m0 I1 v5 `! {: m  M0 T  g
55. }
    
56. 
    : d' d  M1 i) ~2 ~/ f4 _
57. 
    
58. static void move_left_linear_timecode_raw_nbits(unsigned char *raw, unsigned char nbytes, unsigned short nbits)
    
59. {
    : p8 ^; m7 r5 R
60.     unsigned char x, y;
    - N1 D. r5 {8 Y
61. 
    
62.     x = nbits / 8;
    * W6 M) a, S, `
63.     y = nbits % 8;
    
64. 
    
65.     if(x > 0) {
    / E. w9 G. J1 _/ x8 E' S
66.         for (int i = 0; i < nbytes ; i++) {
    0 a; Q: E, k! h7 j! g! M, O$ O
67.             raw[nbytes-i-1] = raw[nbytes-i-1-x];
    * J: W4 l3 ~1 o1 C! `" E# I
68.         }
    & W9 ?. O& r4 B9 `& v' {
69.     }
    
70.     move_left_linear_timecode_raw_7bits(raw, nbytes, y);
    
71. }
    
72. 
    
73. unsigned char get_bit_linear_timecode_raw(unsigned char index)
    6 U1 r; p( c& z9 v& C( j
74. {
    
75.     unsigned char x = index/8;
    2 a: m9 h% G( ^5 j# Y3 I# ]
76.     unsigned char y = index%8;
    
77. 
    
78.     if(linear_timecode_raw[x] & (1 <<y))
    
79.         return 1;
    + o$ N; B1 }# a0 J
80.     else
    0 [, a. U/ V0 \4 V; t. d
81.         return 0;
    
82. }
    
83. 
    
84. static void parse_differential_manchester_code(unsigned char *src,  unsigned char *dst, unsigned char dst_size)
    ; W( m' m8 a) Z: T/ b
85. {
    7 m! U7 L3 f8 H
86.     unsigned char i, j;
    
87.     unsigned short tmp, tmp2;
    " {1 A3 D: K) p+ E9 I0 b
88. 
    " c1 {! A; [; y1 p. z; |
89.     for(i=0; i<dst_size; i++) {
    ' b' @: u4 k# N5 @7 x
90. 
    9 }3 ?% R2 G/ X- l
91.         tmp = (src[i*2 +1] << 8) + src[i*2];
    
92.         dst</span><span style="font-style: normal;"> = 0;
    : X" Y& d  l, k/ L. n
93.         for(j=0; j<8; j++) {
    5 x: Q, t- i4 O9 f9 a
94.             tmp2 = tmp & (3 << j*2);
    
95.             tmp2 >>= j*2;
    
96.             if((0 != tmp2) && (3 != tmp2)) {
    " ?9 ]; M2 {* A2 O3 x% H/ a  `
97.                 dst</span><span style="font-style: normal;"> |= (1<<j);
    
98.             }
    7 S' t% T' \: T0 u8 p. Z3 E
99.         }
    2 i. B7 q! r  J5 D4 q7 r2 h
100.     }
     
101. }
     ; o4 k- K2 b- u! _8 G" P
102. 
     
103. static char find_sync_code(unsigned char *src, unsigned char len, unsigned char *dst, unsigned char *valid_len)
     
104. {
     3 Q% p: X5 e" \$ g
105.     const unsigned short sync_code = 0xFCBF;
     
106.     unsigned char i;
     
107.     unsigned short tmp;
     6 o$ }0 o. c  \; P3 Z" w
108.     char ret=-1;
     
109. 
     ' T% T" \* }& B4 H5 w' F
110.     for (i=0; i<len-8; i++) {
     
111.         tmp = (src[i+8] << 8) + src[i+9];
     $ ^1 b! |% ~; r& S" w3 r, b
112.         if (tmp == sync_code) {
     / h+ e9 S) c4 a2 ~( F! P
113.             ret =0;
     
114.             *valid_len = len - i;
     2 z7 K2 X. Z( G  q) j
115.             memcpy(dst, &src</span><span style="font-style: normal;">, 10);   //10Bytes equals 80bits
     
116.             break;
     $ q; ~6 t) Y' z- N
117.         }
     - ?- T$ q! a4 w. f) T. l' }# u! Z
118.     }
     
119. 
     
120.     return ret;
     $ M! h7 G6 H. t* ^3 R
121. 
     ; T- Q2 M! `& w$ H
122. }
     : `0 s" x3 r% [1 r* L6 O$ r) J
123. 
     
124. unsigned char ltc_dst_code[40][10]= {0};
     : [2 Y. x' b) I$ `( H5 |  X
125. unsigned char ltc_dst_code_count = 0;
     8 B- F0 e1 W% X+ d5 m
126. unsigned char ltc_code_valid_len=0;
     1 _4 P* U# _/ {- O) _
127. unsigned char ltc_code[20] = {0};
     " d3 W: H' a* E. V
128. unsigned char raw_ready[60] = {0};
     
129. unsigned short offset_bits = 0;
     ; G! @7 D0 f' r, l7 ^
130. unsigned short ltc_remain_bits = 0;
     $ t3 w; Q& w; s& M: p
131. unsigned char sec_ltc_code[20] = {0};
     # A$ v- {' E. r+ o; v0 z
132. unsigned char ltc_dst_code_cur[10]= {0};
     
133. unsigned char new_frame =0;
     % ^+ y- p$ k" d$ }) k. Z
134. 
     
135. 
     9 K# E, w' w0 t8 p
136. void parse_linear_timecode_raw()
     2 w. g3 a) J( R" b4 B
137. {
     + u/ _8 a: l) S" K
138.     unsigned char tmp;
     
139.     unsigned char raw_mv_right_bits = 0;
     
140. 
     
141.     if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
     9 ?4 e/ B5 W  t% L. M. O- g, _' [
142.         isjam = 0;
     
143.         memcpy(raw_ready, linear_timecode_raw_ready, sizeof(linear_timecode_raw_ready));
     / C# m( {9 W0 g
144.         tmp = raw_ready[0] & 0x03;
     
145.         while((0 != tmp) && (3 != tmp)) {
     2 D# P( [$ A2 O+ h$ b0 K
146.             move_right_linear_timecode_raw_nbits(raw_ready, sizeof(raw_ready), 1);
       f# G( L: C4 E! [9 n; {
147.             raw_mv_right_bits ++;
     ) e! F! G# F  k0 w" v4 g
148.             tmp = raw_ready[0] & 0x03;
     2 u# ]7 g# c- c$ s* U% K! Q
149.         }
     
150. 
     
151.         for (int i = 0; i < sizeof(linear_timecode_raw_ready)*8; ++i) {
     ) O5 u: ^" S& z% V+ \6 i) Z, |
152.             memset(ltc_code, 0 , sizeof(ltc_code));
     
153.             parse_differential_manchester_code(raw_ready,  ltc_code, sizeof(ltc_code));
     8 x5 N- E/ P; W. Y& x
154.             //0xFCBF;
     9 \3 _5 q! o5 V) J: N9 r/ }0 T
155.             if((ltc_code[8] == 0xFC)&&(ltc_code[9]==0xBF)) {
     
156.                 linear_timecode_status = !LTC_STATUS_NEED_FIND_SYNC;
     
157.                 offset_bits = raw_mv_right_bits;
     
158.                 break;
     
159.             }
     
160.             move_right_linear_timecode_raw_nbits(raw_ready, sizeof(raw_ready), 1);
     * a( e/ N: {, L! f) v
161.             raw_mv_right_bits ++;
     
162.         }
     
163. 
     . q8 V" |2 o* E3 c$ |
164.         if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
     
165.             LtcInput.tim_count = 0;     //reflesh tim2 period
     
166.         }
     
167. 
     
168.     } else {
     
169.         isjam = 1;
     # Z' `5 I, F2 u1 |& E- s
170.         memcpy(ltc_code, linear_timecode_raw_ready, sizeof(ltc_code));
     7 ?( b0 D& p5 v! J7 t; n. a# E
171.         parse_differential_manchester_code(ltc_code,  ltc_dst_code_cur, sizeof(ltc_dst_code_cur));
     9 s, M2 b$ a$ ?; H. P7 R2 U8 @
172.         if((ltc_dst_code_cur[8] != 0xFC)||(ltc_dst_code_cur[9]!=0xBF)) {
     
173.             linear_timecode_status = LTC_STATUS_NEED_FIND_SYNC;
     ) U  _3 x$ H& ^2 M  ]* J( S6 l% x
174.             LtcInput.tim_count = 0;     //reflesh tim2 period
     
175.         } else {
     
176.             new_frame =1;
     
177.         }
     0 n2 y- U  ~0 d
178.     }
     $ B/ d3 j! W4 K. q
179. }
     
180. </span></span>

复制代码

3 O2 K* T1 m. B: Y总结以及调试过程中发现的问题。

# I2 ]. [7 {% r9 x, B$ m: b1. 测量周期，比较顺利， 56MHz ， 测量出脉冲周期202 us

/ a3 ^- U, {4 Z! T' H
2. 采样过程中，发现定时器中断，在修正过程中， 出现中断异常，增加调试口翻转看波形
5 J1 e5 _0 w+ \" M
异常1， 中断回调，里面调用HAL_TIM_xxx ,  导致反复进入定时器中断,

: D4 z: d8 e5 R1 F& h) X" A9 F2 u

: T+ v% s( X/ T2 {2 w& M异常2， 定时器停止-> 修改周期 -> 定时器启动，每次启动都会中断一下，启动前清中断标志也不行
+ \8 p. Q$ h5 r8 }0 Y0 X

, I  n/ K# y8 \) S9 w
* Z% _5 j! K1 p1 y8 K" N  `, `解决办法，通修改 TIM中断处理程序，直接修改寄存器。 中间不停止，最终得到正确的波形
: R. o7 y. h0 e" w

1. void TIM3_IRQHandler(void)
   
2. {
   
3.   /* USER CODE BEGIN TIM3_IRQn 0 */
   
4. 
   
5.   /* USER CODE END TIM3_IRQn 0 */
   
6.   HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
   - r- m* N" Y+ l- w
7.   htim3.Instance->SR = 0;
   . T) c. z8 N7 z# h: n! `
8.   htim3.Instance->ARR = LtcInput.period;
   * q: P& F7 y3 D) G) ?
9.   htim3.Instance->CNT = 0;
   
10.   ltc_input_timer_callback();
    7 X+ J/ s, h3 E" C
11. 
    
12.   /* USER CODE END TIM3_IRQn 1 */
    $ R0 E8 p  f0 ?$ b' m+ k' G
13. }

复制代码

0 f, s9 L4 ?. m$ ?- l. v

( |/ r2 n7 H/ S8 z