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

实现原理，
- a. G' d6 R! }- `: s+ l: x+ J
, b+ ?1 z0 S8 w* }( g, N1.  EXTI  Rising/Falling 中断+定时器方式测量100次波形脉冲宽度，通过排序算法找到合适的值确定为定时器周期值Period
9 g. u- S/ |& S/ j2 E$ E* T
1 {/ {* u- R( g( Q2.  继续用EXTI  Rising/Falling 中断+定时器方式接收时间码0101值， EXTI  Rising/Falling 中断时，修正定时器中断周期为Period/2。

5 [- r2 R& r7 ^, K$ U: T* ^4 k产生定时器中断之后，取Pin 值保存，修正定时器中断周期为Period

3.  解析差分曼切斯特编码，查找同步码

( [9 G1 {8 |( |: q# ]6 o( M流程图，

* ]$ R+ e' [' H# {/ F
关键过程代码，

& e6 k2 X: d4 U$ O% q7 H. P1. EXIT 中断处理

/ ]! Q4 n' I% x% W

1. struct LtcInput_s LtcInput = {
     P! j# q; y4 V. b" F' R
2.     .tim = {0},
   
3.     .tim_count = 0,
   : t, Q* Y5 V* P  r
4.     .period = 0xffff,
   
5. };
   
6. 
   
7. static uint16_t parse_tim_of_ltc_input_get_period(void)
   % B( I3 I/ _  T6 x, U
8. {
   
9.     for (int i = 0; i < LTC_INPUT_BUF_SIZE; ++i) {
   ' ~: N% D  l4 M; q- P% a2 S4 h
10.         for (int j = i; j < LTC_INPUT_BUF_SIZE; ++j) {
    
11.             if(LtcInput.tim<i> > LtcInput.tim[j]) {</i>
    & C" h% Q8 \* k. U% @  G
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;
    2 c7 D. x' J2 i. Z  y
15.             </i><span style="font-style: normal;">}
      w; [. H* a& N! S+ R8 f8 ^
16.         }
    
17.     }
    + x1 [# ~0 y( D6 G. C& P
18.     uint16_t period = LtcInput.tim[10];
    
19.     return period;
    $ |, M. h, z- `) J- b( G
20. }
    
21. 
    
22. void ltc_input_timer_restart(int period)
    1 R$ Z! j3 x* F
23. {
    : f) G( r; h" R; I
24. 
    & w8 i* k# N# f1 r, k
25.   htim3.Instance->SR = 0;
    
26. htim3.Instance->ARR = period;
    8 r: A: \9 t3 R' g0 i6 a2 r% K
27. htim3.Instance->CNT = 0;
    
28. 
    
29. }
    
30. 
    
31. void ltc_input_pin_callback(void)
    
32. {
    5 O- \/ ~1 B* z
33.     // HAL_TIM_Base_Stop_IT(&htim3);
    $ ]  i* V) x; W/ J
34.     if(LtcInput.tim_count >= LTC_INPUT_BUF_SIZE) {
    6 R5 ~3 ?7 y3 I# t6 b/ `$ V$ w
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.         }
    3 {' `8 q! m+ k6 y! ?
42.         ltc_input_timer_restart(0xffff);
    . `+ l7 t% [. K" B1 w5 S
43.     }
    $ q0 N. b& b7 ~
44. }</span></span>

复制代码

2. 定时器处理

1. /**
   / K. o+ E# s; S6 x: v& b
2.   * @brief This function handles TIM3 global interrupt.
   / a6 t0 X" ~' A9 u; _+ t
3.   */
   , m6 ^& q' s+ x2 |/ U
4. void TIM3_IRQHandler(void)
   
5. {
   & u1 n4 d5 f' _
6.   /* USER CODE BEGIN TIM3_IRQn 0 */
   : U! |/ d& o0 t
7. 
   
8.   /* USER CODE END TIM3_IRQn 0 */
   
9.   HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
   2 B! j7 |: c! _0 p7 C
10.   htim3.Instance->SR = 0;
    7 m: I- C9 i7 K  x- g; l
11.   htim3.Instance->ARR = LtcInput.period;
    
12.   htim3.Instance->CNT = 0;
    
13.   ltc_input_timer_callback();
    
14. 
    
15.   /* USER CODE END TIM3_IRQn 1 */
    ' ^0 @3 N# g% r6 C' O: |9 V0 Z% A
16. }
    
17. 
    - t' C/ [, B8 N2 X% v
18. char ltc_input_timer_callback(void)
    $ H8 w0 L% ]3 h, W4 e
19. {
    - G: F% G, O3 y. S: r$ K
20.     GPIO_PinState status;
    
21.     unsigned char x, y;
    
22. 
    
23.     status = HAL_GPIO_ReadPin(LTC_INPUT_GPIO_Port, LTC_INPUT_Pin);
    
24.     //status = GPIO_ReadInputDataBit(LTC_PORT, LTC_PIN);
    1 U% m8 e# N- x- V4 |# x  O$ U2 K
25.     //HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
    
26. 
    
27.     //GPIO_WriteBit(TEST_PORT, TEST_PIN, status);
    
28.     //GPIO_WriteBit(TEST_PORT, TEST_PIN, SET);
    
29.     //move_right_linear_timecode_raw(linear_timecode_raw, sizeof(linear_timecode_raw));
    + P! u* ~1 a: X4 g
30. 
    
31.     x = linear_timecode_count /8;
    
32.     y = linear_timecode_count %8;
    
33. 
    ) R' Q7 W5 I  e
34.     //buf[linear_timecode_count] = status;
    : ^$ B5 z1 n0 u
35.     linear_timecode_raw[x] &= ~(1 << y);
    4 @/ h1 E/ a0 ]& s% L, {
36. 
    
37.     if(status != GPIO_PIN_RESET) {
    * M6 e  F1 _! ?
38.         linear_timecode_raw[x] |= (1 << y);
    
39.     }
    
40. 
    6 E  ~  @' {4 I) S, J, h: j
41.     linear_timecode_count ++;
    5 z4 j4 V8 J$ f  z2 A/ |
42. 
    
43.     if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
    9 e" z( R6 U0 m3 k9 ~
44.         if(linear_timecode_count >= sizeof(linear_timecode_raw) * 8) {
    
45.             linear_timecode_count =0;
    3 i2 u! g8 }8 K* `; V# g* W
46.             memcpy(linear_timecode_raw_ready, linear_timecode_raw, sizeof(linear_timecode_raw));
    
47.             linear_timecode_ready = 1;
    3 M0 e- I1 S3 N+ @3 u: ], ]8 ?# s
48.         }
    / F% R: x7 }9 ^2 w" ^4 U
49.     } else {
    
50.         if(offset_bits > 0) {
    7 |. J! F& b2 X0 Y$ N3 h8 B3 [
51.             //skip offset_bits
      ^3 A" z( R3 q. {
52.             //If offset < linear_timecode_count, adjust the offset to the next frame.
    + }8 A3 j" u! n
53.             //Next time, when count = offset, the counter is cleared. From then on, each frame starts from scratch.
    9 r8 K2 ]' v- }
54.             if(linear_timecode_count > offset_bits) {
    2 S; y/ h& R( R2 M8 w" n7 Z9 L
55.                  offset_bits += 160;
    8 S% a4 n0 R, H4 T( V: i. b2 z
56.             } else if(linear_timecode_count == offset_bits) {
    
57.                 offset_bits = 0;
    
58.                 linear_timecode_count = 0;
    
59.             }
    
60.         } else {
    
61.             if(linear_timecode_count >= sizeof(linear_timecode_raw) * 8 / 2) {
    2 F  {2 R4 ~/ Z8 t/ E. y- Q
62.                 linear_timecode_count =0;
    % C, d3 w5 p* Q5 o7 f+ }0 M* J
63.                 memcpy(linear_timecode_raw_ready, linear_timecode_raw, sizeof(linear_timecode_raw) / 2);
    $ Y/ l8 @, E' P
64.                 linear_timecode_ready = 1;
    
65.             }
    
66.         }
    + F# J( n0 f; v2 T
67.     }
    8 N5 E9 K7 v! F
68.     return 0;
    
69. }

复制代码

3.  差分曼切斯特码解码

1. 
   3 L4 A; E+ b( ?* {: T
2. unsigned char r_mask[] = {0x0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
   8 }, r0 v/ s+ C
3. unsigned char l_mask[] = {0x0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
   1 q) u) e0 m4 n& Z& k# t8 @+ |
4. 
   / r! G; z, k% b1 O0 c
5. static void move_right_linear_timecode_raw_7bits(unsigned char *raw, unsigned char nbytes, unsigned char nbits)
   ; S" `# f# e" m( ?
6. {
   
7.     unsigned char i;
     w. l4 }9 C; ^5 M
8.     unsigned char tmp;
   
9. 
   
10.     if((nbits < 1) || (nbits > 7)) {
    
11.         return;
    
12.     }
    
13. 
    ) x* P8 X5 I- W9 p* u  H
14.     for(i=0; i<nbytes - 1; i++) {
    
15.         tmp = raw[i+1] & r_mask[nbits];
    0 N8 [7 c, u& D, x
16.         tmp <<= (8-nbits);
    . @$ ?  Y' u7 O7 e1 ~
17.         raw<span style="font-style: italic;"><span style="font-style: normal;"> >>= nbits;
    
18.         raw</span><span style="font-style: normal;"> += tmp;
    
19.     }
    , ^3 n: a# b# _8 `) g, ~+ f) Z
20.     raw</span><span style="font-style: normal;"> >>= nbits;
    # I* j* K( D% z5 W8 b6 m5 M2 a0 H9 c
21. }
    
22. 
    $ |+ v3 |: f1 D$ @
23. static void move_left_linear_timecode_raw_7bits(unsigned char *raw, unsigned char nbytes, unsigned char nbits)
    
24. {
    
25.     unsigned char i;
    ) d% k7 y9 o% G- i+ Z
26.     unsigned char tmp;
    
27. 
    
28.     if((nbits < 1) || (nbits > 7)) {
    ( r2 j/ i8 v6 I' Q% R- u
29.         return;
    2 i0 c; m; e6 q: C: _5 `
30.     }
    ) U& R: D: n5 g1 Q9 F
31. 
    
32.     for(i=0; i<nbytes - 1; i++) {
    
33.         //prev_bit = raw</span><span style="font-style: normal;"> & 0x80;
    ' R3 `! o& O$ {+ i% B/ U" [- C+ _
34.         tmp = raw[nbytes - i - 2] & l_mask[nbits];
    1 S' t& T- o- W
35.         raw[nbytes - i -1] <<= nbits;
    1 X4 V, g- E8 F) ^& K& w9 [
36.         tmp >>= (8-nbits);
    - h8 X# Y, N+ N
37.         raw[nbytes - i -1] += tmp;
    
38.     }
    0 g: |1 _! ~5 z5 e* v: s! Q
39.     raw[0] <<= nbits;
    
40. }
    " `4 W# T6 i6 G% i
41. 
    " W! X% k6 L- Q8 D- r$ q$ y
42. static void move_right_linear_timecode_raw_nbits(unsigned char *raw, unsigned char nbytes, unsigned short nbits)
    
43. {
    
44.     unsigned char x, y;
    2 _: e0 u1 _  N7 O
45. 
    7 g; @) i/ n/ E8 X) J, A+ D  t
46.     x = nbits / 8;
    
47.     y = nbits % 8;
    * Y5 ^8 @' g4 g" i) V' S
48. 
    2 F" W% H0 P& R0 P* S
49.     if(x > 0) {
    
50.         for (int i = 0; i < nbytes ; i++) {
    
51.             raw</span><span style="font-style: normal;"> = raw[x+i];
    
52.         }
    ' P/ J7 G; t. f9 h) J/ D
53.     }
    ) C9 n5 L& A. f+ R8 j
54.     move_right_linear_timecode_raw_7bits(raw, nbytes, y);
    & P: q: a7 o! D8 P. l, U/ k7 y
55. }
    
56. 
    
57. 
    
58. static void move_left_linear_timecode_raw_nbits(unsigned char *raw, unsigned char nbytes, unsigned short nbits)
    
59. {
    & S5 s' z# L  K8 u& c0 E
60.     unsigned char x, y;
    ! P& y6 u: g! L
61. 
    
62.     x = nbits / 8;
    : T' O& U* x* i" e" e. x2 A' J% E
63.     y = nbits % 8;
    * [8 O: Q- ^% X0 z+ k
64. 
    
65.     if(x > 0) {
    
66.         for (int i = 0; i < nbytes ; i++) {
    5 g) L+ H, d7 M+ I' n  L" G
67.             raw[nbytes-i-1] = raw[nbytes-i-1-x];
    
68.         }
    ' ]. x0 k5 W1 |# u: n2 t: Q
69.     }
    
70.     move_left_linear_timecode_raw_7bits(raw, nbytes, y);
    1 h; O+ q2 c# N6 i
71. }
    
72. 
    
73. unsigned char get_bit_linear_timecode_raw(unsigned char index)
    
74. {
    2 y& N6 ~& {) ]. D1 K
75.     unsigned char x = index/8;
    5 G- ], i8 \" @, K# q4 ]+ e7 e
76.     unsigned char y = index%8;
    5 Y# j- P& o2 w# Y: n
77. 
    & i: O" A5 C: X5 E5 H- z
78.     if(linear_timecode_raw[x] & (1 <<y))
    
79.         return 1;
    
80.     else
    ! G( J7 G! p1 F' N. S
81.         return 0;
    
82. }
    6 P& }2 o' a2 n1 k6 K
83. 
      l# W# T7 J: v% X1 f
84. static void parse_differential_manchester_code(unsigned char *src,  unsigned char *dst, unsigned char dst_size)
    
85. {
    $ o% j! T% P0 L6 O4 K) S# ]4 P
86.     unsigned char i, j;
    * F9 L9 y' t; G9 n# d4 P; G
87.     unsigned short tmp, tmp2;
    ! b( |4 n; q7 r8 t' w
88. 
    
89.     for(i=0; i<dst_size; i++) {
    
90. 
    9 [: z' m2 C0 o; V2 d
91.         tmp = (src[i*2 +1] << 8) + src[i*2];
    " K0 Q" O  f. B4 G
92.         dst</span><span style="font-style: normal;"> = 0;
      l. X5 c/ z9 J! P2 [  B
93.         for(j=0; j<8; j++) {
    
94.             tmp2 = tmp & (3 << j*2);
      {8 b3 ]) i9 u9 g/ r
95.             tmp2 >>= j*2;
    
96.             if((0 != tmp2) && (3 != tmp2)) {
    5 U; T7 y9 w0 v' j& Z# X
97.                 dst</span><span style="font-style: normal;"> |= (1<<j);
    
98.             }
    . l! a' @4 D" J
99.         }
    
100.     }
     * o+ P7 D3 u; L
101. }
     
102. 
     2 _$ q6 T/ {5 H. _6 R8 I: C1 p  ]
103. static char find_sync_code(unsigned char *src, unsigned char len, unsigned char *dst, unsigned char *valid_len)
     4 f1 f7 i/ e9 d: j. O+ S: I" u
104. {
     # ]; Y5 y" W, Q
105.     const unsigned short sync_code = 0xFCBF;
     
106.     unsigned char i;
     
107.     unsigned short tmp;
     ) Y5 |' s& }- x8 g. P6 o/ @) P
108.     char ret=-1;
     . s6 l5 C0 m: N- u: w8 T. R
109. 
     1 u; X; ?- N3 X: q6 {0 w" n' [
110.     for (i=0; i<len-8; i++) {
     + m- C3 j$ Q" N5 {  D& N( ?
111.         tmp = (src[i+8] << 8) + src[i+9];
     - p9 T: q; @: ~2 P
112.         if (tmp == sync_code) {
     
113.             ret =0;
     ! |. V6 T. }/ q; T' C  I# K5 @6 ?
114.             *valid_len = len - i;
     
115.             memcpy(dst, &src</span><span style="font-style: normal;">, 10);   //10Bytes equals 80bits
     % I# L! h% T3 i& [4 V9 a
116.             break;
     
117.         }
     ! ?; S5 N+ r" r5 \% |
118.     }
     6 h7 n  T& T# }' X% H
119. 
     - p0 g. O) p( c
120.     return ret;
     7 c0 r1 P6 |  C" s% W
121. 
     4 b, I, J, \% n
122. }
     5 ?( D! x2 S5 M7 t. T  q" ?
123. 
     
124. unsigned char ltc_dst_code[40][10]= {0};
     
125. unsigned char ltc_dst_code_count = 0;
     2 F3 N2 \% c# @1 Y6 B8 J1 c/ _
126. unsigned char ltc_code_valid_len=0;
     ; \% ~5 t( t. ]  t- T" ]
127. unsigned char ltc_code[20] = {0};
     
128. unsigned char raw_ready[60] = {0};
     
129. unsigned short offset_bits = 0;
     
130. unsigned short ltc_remain_bits = 0;
     
131. unsigned char sec_ltc_code[20] = {0};
     
132. unsigned char ltc_dst_code_cur[10]= {0};
     
133. unsigned char new_frame =0;
     
134. 
     ' {( [7 w  P. o% u0 n
135. 
     
136. void parse_linear_timecode_raw()
     
137. {
     & S7 X8 ?$ _! @4 r+ ^6 w, r1 k  f
138.     unsigned char tmp;
     
139.     unsigned char raw_mv_right_bits = 0;
     
140. 
     : u; H6 ]# j2 u4 W4 x
141.     if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
     * v8 q& ~$ q" i  b/ _
142.         isjam = 0;
     5 ~3 r2 j' |  C0 p' Y
143.         memcpy(raw_ready, linear_timecode_raw_ready, sizeof(linear_timecode_raw_ready));
     6 n9 Y1 {- W' S
144.         tmp = raw_ready[0] & 0x03;
     : y$ h, o7 F' q! r* L
145.         while((0 != tmp) && (3 != tmp)) {
     
146.             move_right_linear_timecode_raw_nbits(raw_ready, sizeof(raw_ready), 1);
     , \' L0 J- ^6 l. o, X
147.             raw_mv_right_bits ++;
     ( E4 [+ }- i3 {. {
148.             tmp = raw_ready[0] & 0x03;
     
149.         }
     
150. 
     4 m2 S0 P' z4 J; d5 N  L
151.         for (int i = 0; i < sizeof(linear_timecode_raw_ready)*8; ++i) {
     / G2 j; F7 j. ?4 {1 S1 F
152.             memset(ltc_code, 0 , sizeof(ltc_code));
     
153.             parse_differential_manchester_code(raw_ready,  ltc_code, sizeof(ltc_code));
     , L: d0 s* y) |0 v
154.             //0xFCBF;
     / C) k- U: ]0 c' C
155.             if((ltc_code[8] == 0xFC)&&(ltc_code[9]==0xBF)) {
     " l8 ?* Y  v3 z  K% ^' z. o% o5 B1 w: t
156.                 linear_timecode_status = !LTC_STATUS_NEED_FIND_SYNC;
     
157.                 offset_bits = raw_mv_right_bits;
     8 \  Z' _4 @8 D2 J3 ~, B9 a
158.                 break;
     
159.             }
     . o7 k1 v* k* B8 n* g" c" n
160.             move_right_linear_timecode_raw_nbits(raw_ready, sizeof(raw_ready), 1);
     
161.             raw_mv_right_bits ++;
       e: h: B  [0 }% ]8 ]" u" q
162.         }
     
163. 
       ~) b1 N4 {5 I4 k" E) M" b
164.         if(linear_timecode_status == LTC_STATUS_NEED_FIND_SYNC) {
     
165.             LtcInput.tim_count = 0;     //reflesh tim2 period
     5 m( z! X, c4 l: ]& I
166.         }
     
167. 
     
168.     } else {
     
169.         isjam = 1;
     , a+ T1 N! u, \# S
170.         memcpy(ltc_code, linear_timecode_raw_ready, sizeof(ltc_code));
     
171.         parse_differential_manchester_code(ltc_code,  ltc_dst_code_cur, sizeof(ltc_dst_code_cur));
     ! h9 ]' ]/ c( ?5 G0 j
172.         if((ltc_dst_code_cur[8] != 0xFC)||(ltc_dst_code_cur[9]!=0xBF)) {
     
173.             linear_timecode_status = LTC_STATUS_NEED_FIND_SYNC;
     
174.             LtcInput.tim_count = 0;     //reflesh tim2 period
     4 H# N+ p5 m* y1 J* l
175.         } else {
     2 Z, }& N, h  d. e0 L( D$ \
176.             new_frame =1;
     # A$ N7 H) d0 m# m8 y* F0 n- G
177.         }
     " m# }/ N. k$ Z9 T4 T
178.     }
     4 r5 o1 k1 r( X3 @* \+ |3 \
179. }
     * c! `# L# N( D
180. </span></span>

复制代码

! n8 E( I* m4 Q2 p
" U+ y# v9 c7 k* a! S总结以及调试过程中发现的问题。
. }' I( U! L0 o! X
1. 测量周期，比较顺利， 56MHz ， 测量出脉冲周期202 us

1 R: j, x3 f8 K7 D: y. S- R- n6 f0 v

) y' q. q" t# N( Q* h: K- p- @; y
2. 采样过程中，发现定时器中断，在修正过程中， 出现中断异常，增加调试口翻转看波形
0 H' b+ D8 d! T$ }# [
异常1， 中断回调，里面调用HAL_TIM_xxx ,  导致反复进入定时器中断,
4 I  D) d* X1 f4 k, x( d

2 @3 w  m2 @% {4 f% O异常2， 定时器停止-> 修改周期 -> 定时器启动，每次启动都会中断一下，启动前清中断标志也不行
; Q- \+ g, u, }4 R6 H

8 i, r* v' L6 @. k
解决办法，通修改 TIM中断处理程序，直接修改寄存器。 中间不停止，最终得到正确的波形

1. void TIM3_IRQHandler(void)
   , X5 n: D+ ?$ N/ ^# O5 f/ q, u
2. {
   ; l6 \* M- }+ [% w
3.   /* USER CODE BEGIN TIM3_IRQn 0 */
   4 u3 C# n; m9 v2 U
4. 
   4 }# `* }. X  n5 |0 [* Q# b
5.   /* USER CODE END TIM3_IRQn 0 */
   
6.   HAL_GPIO_TogglePin(TEST1_GPIO_Port, TEST1_Pin);
   : }& q" d4 V7 |) W7 ^' a9 g) {
7.   htim3.Instance->SR = 0;
   
8.   htim3.Instance->ARR = LtcInput.period;
   
9.   htim3.Instance->CNT = 0;
   1 v  [& z( q# C$ x; w1 r4 W/ _
10.   ltc_input_timer_callback();
    
11. 
    
12.   /* USER CODE END TIM3_IRQn 1 */
    & O& L& o% f& n* R7 b9 f9 b
13. }

复制代码

. Y; w# H* n  S, s* s$ M
1 f$ E" @/ T3 D