项目背景
在各类项目开发中，我们会经常涉及到步进电机的控制。一般情况下，单片机都是通过操作步进电机驱动器或驱动芯片实现对步进电机的控制。步进电机驱动器（芯片）一般都是留有三个接口En，Dir，Pul。En是步进电机使能（或脱机）的信号，高电平时，步进电机会断电脱机。Dir是步进电机转向信号，高电平与低电平代表着正转与反转。Pul是步进电机运动的脉冲信号，每接受到一个脉冲，步进电机运行一步（或一个细分步）。

驱动库介绍
本步进电机驱动库主要实现了对步进电机驱动器上述三种信号的控制，同时也封装好了电机点动、长动、往复三种运动模式。通过将步进电机封装抽象为一个结构体类型，我们可以轻松实现对多个不同步进电机的运动控制。同时，本库函数配套的应用指南中也给出了步进电机与光电对管的配套使用例程。

0 ~( I' p$ z- |& n7 \/ b7 B源码分析
% K: `- U% T# J头文件
* J& x) h7 j/ k( |# E; P头文件中定义了步进电机结构体类型，它是对步进电机（驱动器）控制的抽象，与平台无关。在代码注释中有对每个成员的描述。特别需要注意的是，void StepMotor_TryMove(StepMotor_Struct* StepMotor_P)是电机运动控制的核心函数，它主要负责实现了电机三种运动模式。需要在定时器的更新中断服务函数中周期性的调用此函数。

2 C( a8 I  j+ @4 E

1. /*
   
2. * stepmotor.h
   - q  Q8 ^$ b9 a3 d7 ^: ^$ }
3. *
   
4. *  Created on: 2020年8月31日
   
5. *      Author: Tao
   ! T! C/ ~& Q0 f& g- T4 |- _
6. */
   8 j" P( ~! r0 w& ^3 u1 v
7. 
   
8. #ifndef SOURCE_ALWHALESLIB_HARDWARE_INC_STEPMOTOR_H_
   
9. #define SOURCE_ALWHALESLIB_HARDWARE_INC_STEPMOTOR_H_
   
10. 
    
11. #define USE_STEPMOTOR
    ( Z2 s( ~( n) R
12. 
    
13. #ifdef USE_STEPMOTOR
    - V7 b6 k( D  A, A: z, X* Z
14. 
    4 J- \4 U* Q' Z  ]1 `
15. #include "stepmotor.h"
    & X5 s# T/ h% O9 D5 {! ~, X3 J
16. #include "stm32f10x_conf.h"
    ; g: s9 A. N# c+ I9 H8 J! ?
17. 
    
18. #define SETPMOTOR_NUM                4
    9 k! A1 m) ^; w- t  Z: ]! d& ~. b
19. 
    - f+ W5 `: J/ c5 V. K  I# P
20. /***步进电机的控制引脚映射***/
    
21. #define STEPMOTOR_1_EN                        GPIOB_OUT(15)
    
22. #define STEPMOTOR_1_DIR                        GPIOB_OUT(13)
    
23. #define STEPMOTOR_1_PUL                        GPIOB_OUT(14)
    4 [' G" R; ?% y% Y% p- d/ X
24. 
    
25. #define STEPMOTOR_2_EN                        GPIOD_OUT(10)
    
26. #define STEPMOTOR_2_DIR                        GPIOD_OUT(8)
    4 d# N' f, A5 x& n( G
27. #define STEPMOTOR_2_PUL                        GPIOD_OUT(9)
    
28. 
    ' j% w% \" Q. T6 Q3 q
29. #define STEPMOTOR_3_EN                        GPIOD_OUT(13)
    0 |/ S" v; A9 X9 X0 I8 S) r! ^
30. #define STEPMOTOR_3_DIR                        GPIOD_OUT(11)
    
31. #define STEPMOTOR_3_PUL                        GPIOD_OUT(12)
    1 B; S4 p" I* K$ Z) m! a. i
32. 
    
33. #define STEPMOTOR_4_EN                        GPIOC_OUT(6)
    
34. #define STEPMOTOR_4_DIR                        GPIOD_OUT(14)
    
35. #define STEPMOTOR_4_PUL                        GPIOD_OUT(15)
    
36. /*******************************/
    
37. 
    % U. z/ G" z( W& |& L9 [/ f$ h% @
38. 
    3 u0 E2 n2 e" i. e3 e
39. typedef void (*SetState_FP)(uint8_t state);
    $ y! ^2 k$ P6 d" u+ R" H7 W, n
40. typedef void (*SetParam_FP)(uint32_t param);
    8 N, l; F0 u6 Z$ V, h$ y5 {
41. 
    
42. /**
    
43. * @brief 步进电机的结构体封装
    / |$ J/ a2 K/ b. ~- A
44. *                         triggerCount是电机单步运动的边沿次数，1: 单次，即电平跳变, 2: 双次，即脉冲
    
45. *                         SetPulse是驱动电机运动的函数指针，一般情况下，应该为它注册一个操作GPIO端口电平的指针
    
46. *                         一般会在定时器的更新中断服务函数中调用SetPulse，每次调用都将端口电平翻转
    
47. *                         triggerCount = 1 时，定时器的更新频率 = 步进电机速度（步/s）
    
48. *                         triggerCount = 2 时，定时器的更新频率/2 = 步进电机速度（步/s）
    / E- y( x4 I0 {; r; M8 v
49. *
    5 b: P+ Z9 Q. Q* P; F
50. *                        一般通过定时器驱动步进电机的运动，定时器的启停即为电机的启停，定时器的频率即为电机的速度
    
51. *                         SetExec设置电机运动启停的函数指针，一般情况下，应该为它注册一个可以打开、关闭驱动定时器的函数
    
52. *                         SetSpeed是设置电机运动速度的函数指针，一般情况下，应该为它注册一个可以设置驱动定时器的更新周期的函数
    ) k! K9 d7 a  M- M0 x
53. */
    
54. typedef struct
    * _9 y- W" Q# Z& Y
55. {
    
56.         //电机是否正在运动
    
57.         uint8_t IsRun;
      y# Y6 b! j$ ?
58. 
    4 @4 D& K7 y$ ^) B; y3 o
59.         //电机单步运动的边沿次数（1: 单次，即电平跳变, 2: 双次，即脉冲）
    / y* \: N* E$ f4 a6 ]. S! b% _9 J
60.         uint8_t triggerNum;
    # T: Z# Z1 j0 L) L; I( W
61. 
    
62.         //电机运行的步数计数
    + D2 W+ d8 {( C# q
63.         uint32_t StepCount;
    
64. 
    
65.         //电机循环计数（仅在工作模式为往复时生效）
    ' N- Y. Y; K. U3 W
66.         uint8_t LoopCount;
      l2 X. A" a  H% T3 a
67. 
    
68.         //电机设置运动步数
    
69.         uint32_t StepSV;
    
70. 
    
71.         //电机的工作模式（0:距离, 1:往复, 2:长动）
    5 b; G( @5 r3 o/ X
72.         uint8_t WorkMode;
    
73. 
    
74.         //驱动步进电机的硬件定时器指针，
    
75.         //此成员与硬件相关，设置它的主要目的是为了编写各处理函数时的方便
    / e& k. C1 b( C! |/ T
76. //        TIM_TypeDef* DriveTimer;
    
77. 
    & `* G' q( m& t/ m! e
78.         //设置激活电机的函数指针（激活电机后，电机将处于锁定状态，相当于通电）
    
79.         //只有处于激活状态的电机才能被控制
    
80.         SetState_FP SetEn;
    
81. 
    ) t  t  q6 @% z, a8 E1 ~
82.         //设置电机运动方向的函数指针（0:正方向, 1:逆方向, 2:翻转方向）
    * R. j& Y0 H5 |
83.         SetState_FP SetDir;
    
84. 
    
85.         //电机单步运动的函数指针（0:低电平, 1:高电平, 2:翻转电平）
    + q; [3 G+ h( ~% q8 H
86.         SetState_FP SetPulse;
    
87. 
    0 K8 P+ G5 W" K* Z
88.         //设置电机运动速度的函数指针
    0 J5 K& A1 m9 n
89.         SetParam_FP SetSpeed;
    ) n. W% w9 z" ]! M7 G
90. 
    8 O# s, ?/ R5 @4 u+ l
91.         //设置电机运动启停的函数指针
    
92.         SetState_FP SetExec;
    
93. } StepMotor_Struct;
    / r6 |5 Z# {# X; i2 F; E
94. 
    5 d+ _" Q7 [9 A, J* T$ v6 _1 B
95. extern StepMotor_Struct StepMotor[SETPMOTOR_NUM];
    9 P$ j; c" q- D3 N- U8 A
96. 
    9 q9 O( i9 O& A
97. void StepMotor_Init();
    0 n5 C( i. E! E
98. void StepMotor_SetWorkMode(StepMotor_Struct* StepMotor_P, uint8_t mode);
    ; }; y  v, x* H6 G
99. void StepMotor_SetLoopCount(StepMotor_Struct* StepMotor_P, uint32_t loopCount);
    
100. void StepMotor_SetStep(StepMotor_Struct* StepMotor_P, uint32_t step);
     ! w9 j! S* K6 Z% c7 j. ^
101. void StepMotor_TryMove(StepMotor_Struct* StepMotor_P);
     1 F, B9 R( C' j- o5 s
102. 
     
103. #endif
     
104. #endif /* SOURCE_ALWHALESLIB_HARDWARE_INC_STEPMOTOR_H_ */

复制代码

4 Q9 B; R/ C, F5 J源文件
1 O$ j. f5 m" ?, b) k0 P$ R* @在源文件中，静态函数static void StepMotor_1_SetEn_Handler(uint8_t state),…,static void StepMotor_4_SetExec_Handler(uint8_t state)是与平台相关的代码，它们用来注册步进电机结构体成员的各功能函数指针。
# F) e6 X# `1 p) x9 n. u+ d# V( z! N
3 N8 Q9 ^3 |, \! ~0 n1 LStepMotor_Struct StepMotor[SETPMOTOR_NUM]结构体数组在声明时就直接进行了初始化。当然也可以利用void StepMotor_Init()函数（本源码中没有实现）实现上述结构体数组的初始化。与平台相关的代码主要在静态函数中，它们是抽象电机控制的具体实现。
; Q: _- K6 V- S8 a7 H( F$ G
初始化结构体数组之后，所有对步进电机的控制都是围绕操作结构体成员展开。当然可以直接操作结构体成员，但笔者推荐使用封装好的常用步进电机操作函数来控制步进电机，例如void StepMotor_SetWorkMode(StepMotor_Struct* StepMotor_P, uint8_t mode),void StepMotor_SetStep(StepMotor_Struct* StepMotor_P, uint32_t step)等。

1. /*
   ( J% V) _- L- t5 [3 F
2. * stepmotor.c
   
3. *
     A( ?$ @5 E% n  Y9 `
4. *  Created on: 2020年8月31日
   
5. *      Author: Tao
   & F$ Z: U/ a. u5 V! w0 n
6. */
   
7. 
   
8. #include "stepmotor.h"
   
9. 
   ! e( I7 O6 p5 J9 R8 G
10. #ifdef USE_STEPMOTOR
    
11. 
    ; b" z7 y* g" c. a0 Y' K4 M0 h8 `
12. /**********************************/
    
13. static void StepMotor_1_SetEn_Handler(uint8_t state)
    
14. {
    
15.         STEPMOTOR_1_EN = state;
    
16. }
      E, D5 s& _2 B3 Q9 K7 i4 w' H
17. 
    
18. static void StepMotor_2_SetEn_Handler(uint8_t state)
    
19. {
    3 ^* n/ m! c0 p3 b+ z
20.         STEPMOTOR_2_EN = state;
    $ L. t, ?6 x  @6 ~: B/ m
21. }
    * ^- g5 M4 I* g+ Q
22. 
    * |9 S/ ?' d2 S# i) c
23. static void StepMotor_3_SetEn_Handler(uint8_t state)
    . e9 h) p7 R; f9 @0 o6 T+ D
24. {
    . `: {8 j& {% z6 h0 s: b2 s
25.         STEPMOTOR_3_EN = state;
    
26. }
    
27. 
    2 J) W- m6 M1 D7 U$ k  s( o: L# Q4 Q* K8 t
28. static void StepMotor_4_SetEn_Handler(uint8_t state)
    
29. {
    , ^+ Y* x, j+ E6 R/ f& l
30.         STEPMOTOR_4_EN = state;
    ' `  z: Y: x0 c" z: q5 c7 \
31. }
    - x- f! @1 \. @% M! Y6 \& e
32. 
    2 T4 S' L# ?" L3 S
33. /**********************************/
    8 ^3 u0 c# x5 o% @) `
34. static void StepMotor_1_SetDir_Handler(uint8_t state)
      x  c/ \7 ^% q5 w( [
35. {
    
36.         if(state < 2)
    
37.         {
    
38.                 STEPMOTOR_1_DIR = state;
    
39.         }
    9 \3 T; _' H; R. Q& g% A# p/ ]
40.         else
    
41.         {
    6 D1 z3 J: N7 K1 G3 |2 m( m6 X5 u
42.                 STEPMOTOR_1_DIR = ~STEPMOTOR_1_DIR;
    
43.         }
    
44. }
    
45. 
    5 {! }# D. p- U5 J% |
46. static void StepMotor_2_SetDir_Handler(uint8_t state)
    
47. {
    
48.         if(state < 2)
    
49.         {
    + K. P6 o" D. ~5 f, F# L, S0 |
50.                 STEPMOTOR_2_DIR = state;
    
51.         }
    
52.         else
    
53.         {
    & W8 O4 }2 ?( C0 B1 s; n% I& H
54.                 STEPMOTOR_2_DIR = ~STEPMOTOR_2_DIR;
    
55.         }
    - k# ?2 P, u8 \% V8 K6 B+ k
56. }
    8 k5 v* k3 t5 L6 C- K8 f: N1 a
57. 
    ! g) q6 N% `6 W$ f/ l% T1 T* ?
58. static void StepMotor_3_SetDir_Handler(uint8_t state)
    / ^! P6 P+ N, f/ ^/ l8 W" j! |
59. {
    
60.         if(state < 2)
    7 y, w) Y( f8 |& X+ d& s
61.         {
    8 p, Q$ ?. E/ d; Q
62.                 STEPMOTOR_3_DIR = state;
    
63.         }
    ; u# V1 j) E5 H2 I+ o
64.         else
    - R$ _- l  K& z  O/ ~9 E3 {5 P2 h
65.         {
    8 [  Y1 b0 s, y5 g0 k  d
66.                 STEPMOTOR_3_DIR = ~STEPMOTOR_3_DIR;
    " E2 o4 e5 h& o! S% h
67.         }
    
68. }
    ! O( I, `" U; |& T
69. 
    
70. static void StepMotor_4_SetDir_Handler(uint8_t state)
    ! |+ O9 R9 K( f, b7 S5 D
71. {
    
72.         if(state < 2)
    
73.         {
    
74.                 STEPMOTOR_4_DIR = state;
    $ X" k& V9 ~3 U
75.         }
    4 [- }/ \" a4 k. Q3 u
76.         else
    
77.         {
    
78.                 STEPMOTOR_4_DIR = ~STEPMOTOR_4_DIR;
    
79.         }
    
80. }
    , P6 X! n5 R2 ]. F
81. 
    
82. /**********************************/
    
83. static void StepMotor_1_SetPulse_Handler(uint8_t state)
    # ]$ C; E9 V3 t# G3 o9 `% @6 n, j
84. {
    
85.         if(state < 2)
    3 H! `* u! a5 E; n
86.         {
    
87.                 STEPMOTOR_1_PUL = state;
    
88.         }
    
89.         else
    
90.         {
    2 J4 f2 T% W) F
91.                 STEPMOTOR_1_PUL = ~STEPMOTOR_1_PUL;
    ! E. |* J' B) Z5 {' U+ S9 n
92.         }
    
93. }
    
94. 
    % f8 R: F3 T( Z( M7 r$ K  I' m
95. static void StepMotor_2_SetPulse_Handler(uint8_t state)
    . k! O! G5 I* ]
96. {
    
97.         if(state < 2)
    % ~9 |; P+ E- K, i0 R' k4 g1 ]# b
98.         {
    $ v' p: N9 k& K: I" ~
99.                 STEPMOTOR_2_PUL = state;
    
100.         }
     % F3 D) U% i" t! L
101.         else
     
102.         {
     $ j( H! o$ @) {4 h9 ?
103.                 STEPMOTOR_2_PUL = ~STEPMOTOR_2_PUL;
     # v8 W5 C5 i+ B, @1 ^! m8 n5 a
104.         }
     + p  ~( g7 v; p) j. ]5 E
105. }
     6 \% N5 x8 @4 z! A
106. 
     
107. static void StepMotor_3_SetPulse_Handler(uint8_t state)
       R& B: Y' [) k
108. {
     
109.         if(state < 2)
     
110.         {
     ; k2 O8 Y( X  ?# o
111.                 STEPMOTOR_3_PUL = state;
     
112.         }
     
113.         else
     
114.         {
     ( V; k  k, s& P$ W9 X% B
115.                 STEPMOTOR_3_PUL = ~STEPMOTOR_3_PUL;
     ' _4 T' e* Q( w3 Z
116.         }
     
117. }
     
118. 
     * i4 p1 d3 W. T# `
119. static void StepMotor_4_SetPulse_Handler(uint8_t state)
     & D# n* t4 N' [+ O% }
120. {
     
121.         if(state < 2)
     6 @" A" @7 ?* Z7 b0 m
122.         {
     
123.                 STEPMOTOR_4_PUL = state;
     
124.         }
     5 y. k5 ]; g# i% `) M
125.         else
     4 X! L0 n/ l6 b
126.         {
     " e, F1 R; R' y
127.                 STEPMOTOR_4_PUL = ~STEPMOTOR_4_PUL;
     ' k- Z3 l. u9 V; y+ g( c
128.         }
     4 O/ G1 `9 b8 g( v/ F4 b+ m2 e
129. }
     $ D  D2 v, g+ P( P" l
130. 
     
131. /**********************************/
     4 O: I0 F9 e, S0 H! W2 x: `
132. static void StepMotor_1_SetSpeed_Handler(uint32_t speed)
     
133. {
     ( s+ B1 ^( P3 j+ ?' I) G; `
134.         speed = speed * StepMotor[0].triggerNum;
     / I2 L$ T8 j1 Z; f0 V
135. 
     
136.         //frequency < 1k, psc = 7200
     + m9 [" M( H8 j8 q
137.         if (speed < 1000)
     
138.         {
     
139.                 TIM5->PSC = 7200 - 1;
     + b( Z. \: O7 J0 _; s- U
140.         }
     
141.         //frequency < 10k, psc = 720
     7 h6 q, o0 U7 X
142.         else if (speed < 10000)
     
143.         {
     
144.                 TIM5->PSC = 720 - 1;
       j6 w$ w+ O- V- g' x! \
145.         }
     
146.         //frequency < 100k, psc = 72
     , K2 S' Q7 p  V1 X
147.         else if (speed < 100000)
     
148.         {
     
149.                 TIM5->PSC = 72 - 1;
     
150.         }
     ; ?/ s4 |; B# M8 s+ u" N* J! [9 N; |
151.         else
     6 l# O9 L& N3 u/ A" p
152.         {
     6 A0 m6 E/ H& o- V8 ~! t
153.                 return;
     2 p$ ~; r, ~! F  F7 u# r
154.         }
     1 N9 _* N2 y' l$ ]/ }2 Y1 D
155. 
     
156.         //Set the update frequency of the timer.
     $ S9 |6 e6 O: K2 v/ F
157.         TIM5->ARR = 72000000.0 / (TIM5->PSC + 1) / speed - 1;
     ( z& z; e/ ~  i  A5 i
158. 
     
159.         return;
     7 R% V. b3 g3 k: r7 Q' g6 x% k! Z
160. }
     / P4 {8 n! ~% `- u: R# T; b+ q0 }5 e) I
161. 
     1 z6 [7 r5 ~5 V. ^8 r
162. static void StepMotor_2_SetSpeed_Handler(uint32_t speed)
     
163. {
     
164.         speed = speed * StepMotor[1].triggerNum;
     ) T: f" ?( V- Q# c0 C1 E+ F
165. 
     ) X3 e2 H7 b/ }& S: M! Y! |  A3 Y
166.         //frequency < 1k, psc = 7200
     
167.         if (speed < 1000)
     - O: q! F  n% B% T4 P
168.         {
     0 e; t; ^: e+ Q' J1 ~# E
169.                 TIM6->PSC = 7200 - 1;
     
170.         }
     # r* ]* c# h' i: ^3 N% F
171.         //frequency < 10k, psc = 720
     % t: W# f. C- ?1 N6 r6 N
172.         else if (speed < 10000)
     8 U  W. J( @1 U& J+ x* |0 E
173.         {
     
174.                 TIM6->PSC = 720 - 1;
     6 L# K* d% u" I' M
175.         }
     
176.         //frequency < 100k, psc = 72
     0 K4 [# f6 Y$ H
177.         else if (speed < 100000)
     8 e3 C$ d0 W8 m0 m2 X9 f
178.         {
     
179.                 TIM6->PSC = 72 - 1;
     % C% T$ u4 D: i: J7 }
180.         }
     $ O' w. T5 A8 O. C- d4 g8 G
181.         else
     
182.         {
     
183.                 return;
     
184.         }
     ) }. h; _- r# o( [7 B
185. 
     
186.         //Set the update frequency of the timer.
     
187.         TIM6->ARR = 72000000.0 / (TIM6->PSC + 1) / speed - 1;
     
188. 
     4 p/ L  E2 u( |3 d3 T
189.         return;
     ) |% `+ g3 j( l/ G: w" b0 X/ q! {
190. }
     ' S- j' L: ]# M# ^+ }
191. 
     . U, N  `. b7 L' [( a1 Y1 y
192. static void StepMotor_3_SetSpeed_Handler(uint32_t speed)
     ; [7 c  b( m3 v! o( Y
193. {
     
194.         speed = speed * StepMotor[2].triggerNum;
     
195. 
     " U% i* v2 m7 o1 L
196.         //frequency < 1k, psc = 7200
       }1 B( p: l5 `% l. g5 {- b1 c
197.         if (speed < 1000)
     
198.         {
     
199.                 TIM7->PSC = 7200 - 1;
     . {  `$ a# I# v2 K% u1 v; t$ W
200.         }
     # c7 H( H& m2 x  l8 Y8 @' W, ?5 z
201.         //frequency < 10k, psc = 720
     
202.         else if (speed < 10000)
     5 \$ |) s2 S1 g" S7 `4 z
203.         {
     
204.                 TIM7->PSC = 720 - 1;
     
205.         }
     $ `! ?' x. D+ J& U- G
206.         //frequency < 100k, psc = 72
     2 e# j# b, |4 e' \
207.         else if (speed < 100000)
     
208.         {
     
209.                 TIM7->PSC = 72 - 1;
     + P; B7 e0 D) U: P" x" n- x
210.         }
     # `/ Q" \& W) Q4 Y: C5 M0 l
211.         else
     6 e3 B. W+ `/ B+ Z2 [
212.         {
     
213.                 return;
     
214.         }
     
215. 
     8 S" ?+ n* n0 r& L
216.         //Set the update frequency of the timer.
     
217.         TIM7->ARR = 72000000.0 / (TIM7->PSC + 1) / speed - 1;
     
218. 
     
219.         return;
     
220. }
     
221. 
     4 i2 T0 P: O7 D+ r
222. static void StepMotor_4_SetSpeed_Handler(uint32_t speed)
     
223. {
     ' |7 Q0 k- ], ]: I) k6 }  b1 ^
224.         speed = speed * StepMotor[3].triggerNum;
     3 N: f# p, D/ ~! M! \9 h8 i& m- H
225. 
     
226.         //frequency < 1k, psc = 7200
     5 M% q6 L, e, [
227.         if (speed < 1000)
     ; F! k3 j! g, P: f3 W% k  _
228.         {
     $ D+ Q/ F$ u, m' f1 G5 F
229.                 TIM8->PSC = 7200 - 1;
     
230.         }
     
231.         //frequency < 10k, psc = 720
     + m* p  V0 h; m1 z, I% L
232.         else if (speed < 10000)
     
233.         {
     
234.                 TIM8->PSC = 720 - 1;
     0 S2 @! f& n8 J. X1 }7 h7 G2 M8 M1 ~9 y
235.         }
     3 U* W+ V# ?3 o3 ]" _
236.         //frequency < 100k, psc = 72
     
237.         else if (speed < 100000)
     # c% h( b* ]6 A: g+ y
238.         {
     9 b4 u7 |' A+ o
239.                 TIM8->PSC = 72 - 1;
     3 a7 k2 u/ @' G6 P' C' ?" A
240.         }
     & O* ?' S6 h7 O! P5 p* \
241.         else
     0 q( _) i- E  w6 I, `' f! V
242.         {
     
243.                 return;
     8 r4 H: l+ ~: u0 S9 ^0 x8 ?& h
244.         }
     . o4 D  |* B8 N5 t. ]/ J1 F9 t
245. 
     # e: M+ L* _9 S& E) k
246.         //Set the update frequency of the timer.
     / r: X7 d4 N( C7 v" k  G$ S6 J
247.         TIM8->ARR = 72000000.0 / (TIM8->PSC + 1) / speed - 1;
     
248. 
     3 Y' Q$ N' {; k( x0 v
249.         return;
     
250. }
     4 N% x6 ^( v1 K( o
251. 
     
252. /**********************************/
     
253. static void StepMotor_1_SetExec_Handler(uint8_t state)
     * ?: h+ Y) L; b  F7 `& q
254. {
     
255.         TIM_Cmd(TIM5, state);
     2 y$ ?% Y5 Z  r
256. }
     
257. 
     
258. static void StepMotor_2_SetExec_Handler(uint8_t state)
     
259. {
     % g. v& K' Y! a4 f/ h' d0 i* A
260.         TIM_Cmd(TIM6, state);
     7 n# n0 Y6 O# p1 H: D. G
261. }
     
262. 
     2 t2 O- e# o% x5 ]) C6 d
263. static void StepMotor_3_SetExec_Handler(uint8_t state)
     : T1 c* ~+ A2 g" q! Q: @, G
264. {
     
265.         TIM_Cmd(TIM7, state);
     
266. }
     
267. 
     
268. static void StepMotor_4_SetExec_Handler(uint8_t state)
     
269. {
     % l- H! J. b( D0 S& u' F
270.         TIM_Cmd(TIM8, state);
     0 e( I1 J! J2 g! {# y. r
271. }
     2 T( n. \- h( c2 Z0 C* V2 _9 t) _' ?+ p  W
272. 
     
273. StepMotor_Struct StepMotor[SETPMOTOR_NUM] =
     ' m9 s6 B5 u- k; n$ t
274. {
     ' D- H+ C6 x" Y, t' W
275.                 //Initialization of step motor 1
     / q8 E) @) [  W  Z, g- S
276.                 {
     ! E( m% {. h1 E
277.                                 .IsRun = 0,
     
278.                                 .triggerNum = 2,
     
279.                                 .StepCount = 0,
     5 @$ m8 ?" R3 I
280.                                 .LoopCount = 0,
     9 c" c6 B" j$ X
281.                                 .StepSV = 100,
     8 }  K6 B: O: i6 r& `
282.                                 .WorkMode = 0,
     
283. 
     & r0 k6 G! s$ c5 ]+ e' F: I9 ?
284.                                 .SetEn = StepMotor_1_SetEn_Handler,
     ; k4 h2 a: B; N# @: ~# i
285.                                 .SetDir = StepMotor_1_SetDir_Handler,
     
286.                                 .SetPulse = StepMotor_1_SetPulse_Handler,
     0 V6 a1 j. K' s: |; [2 s
287.                                 .SetSpeed = StepMotor_1_SetSpeed_Handler,
     9 T7 k) h/ |& r" n6 U$ Y$ n- _( g1 n% r
288.                                 .SetExec = StepMotor_1_SetExec_Handler,
     
289.                 },
     $ q$ X7 n' ]7 G: D# w, j
290. 
     
291.                 //Initialization of step motor 2
     : F2 E: I+ m: h) p- t0 e& c9 J9 ?
292.                 {
     
293.                                 .IsRun = 0,
     
294.                                 .triggerNum = 2,
     ( W! l1 B4 ]# w* b  Y
295.                                 .StepCount = 0,
     5 w, ^5 ?0 o9 r7 H
296.                                 .LoopCount = 0,
     7 p3 J6 d) @+ }; y- j# f% a' K
297.                                 .StepSV = 100,
     , O( u3 z, ], E  j
298.                                 .WorkMode = 0,
     % m3 Q/ }% V5 [5 h  I9 p+ Z
299. 
     
300.                                 .SetEn = StepMotor_2_SetEn_Handler,
     # a; t$ X: T+ z0 `+ S5 v
301.                                 .SetDir = StepMotor_2_SetDir_Handler,
     
302.                                 .SetPulse = StepMotor_2_SetPulse_Handler,
     
303.                                 .SetSpeed = StepMotor_2_SetSpeed_Handler,
     
304.                                 .SetExec = StepMotor_2_SetExec_Handler,
     
305.                 },
     3 `1 |+ u! d. Y0 x
306. 
     
307.                 //Initialization of step motor 3
     
308.                 {
     & @* @% J. _" A) B1 W  B5 p
309.                                 .IsRun = 0,
     1 [3 U) e$ ^3 f( l+ Y
310.                                 .triggerNum = 2,
     1 S3 o/ l. \( R
311.                                 .StepCount = 0,
     4 c0 Y& t7 i( k# H0 s6 A8 I$ B
312.                                 .LoopCount = 0,
     
313.                                 .StepSV = 100,
     
314.                                 .WorkMode = 0,
     2 P# l' u# H- M5 n% R9 \" b
315. 
     
316.                                 .SetEn = StepMotor_3_SetEn_Handler,
     
317.                                 .SetDir = StepMotor_3_SetDir_Handler,
     3 l5 _4 ?5 R+ G- w% u8 z. _% K
318.                                 .SetPulse = StepMotor_3_SetPulse_Handler,
     $ \% N9 ?8 c6 h/ c  I8 M) L2 o
319.                                 .SetSpeed = StepMotor_3_SetSpeed_Handler,
     0 e% Q  E# h5 f. r3 w' u. }- V
320.                                 .SetExec = StepMotor_3_SetExec_Handler,
     ' V& p: {8 K/ s) F  q& y
321.                 },
     
322. 
     
323.                 //Initialization of step motor 4
     % U# H, q; [: s, ?. G7 }
324.                 {
     ' z" ~; }' B7 V- e  f8 }8 w/ `1 W8 R
325.                                 .IsRun = 0,
     3 e. g  E" V9 H# ]5 D1 O
326.                                 .triggerNum = 2,
     
327.                                 .StepCount = 0,
     " B9 d- i. l7 h, Z% r
328.                                 .LoopCount = 0,
     : ~' r% g9 v4 k: k
329.                                 .StepSV = 100,
     
330.                                 .WorkMode = 0,
     
331. 
     
332.                                 .SetEn = StepMotor_4_SetEn_Handler,
     6 z: p! p" d; |4 z
333.                                 .SetDir = StepMotor_4_SetDir_Handler,
     3 A9 `' u5 m* y0 A  V
334.                                 .SetPulse = StepMotor_4_SetPulse_Handler,
     ! |  g8 q$ F" ~; `5 Q/ ]7 J
335.                                 .SetSpeed = StepMotor_4_SetSpeed_Handler,
     , J/ m" B, Y+ S9 W" {: c
336.                                 .SetExec = StepMotor_4_SetExec_Handler,
     
337.                 },
     9 P0 M4 B1 m* i% M, Z% h" l
338. };
     1 A" D8 M2 |* N% g0 v$ p6 h7 J# q
339. 
     
340. 
     
341. /**
     
342. * @brief 完成步进电机的初始化
     
343. */
     
344. void StepMotor_Init()
     
345. {
     * {; M, B+ q1 A
346. 
     , P0 x* \3 k. u* d! N
347. }
     6 V" H% [0 P7 s) U
348. 
     
349. 
     . C0 ?! u2 t/ u" X$ \
350. /**
     
351. * @brief 设置步进电机的运动步数
     
352. *                         运动步数与内部的StepCount, StepSV的关系主要取决于triggerNum，即触发多少次电机实际运行1步。
     - u( b, P+ B' z0 C
353. *                         在驱动信号的形式上即是单边沿触发（triggerNum = 1, 跳变信号）还是双边沿触发（triggerNum = 2, 脉冲信号）
     " X" t* L# M% s
354. *         @param StepMotor_P: 步进电机结构体指针
     : v# z/ c  E* B, a, A2 @- i! f! m
355. *         @param step: 电机运动步数
     ' X: ?7 a, ]# d. X6 z
356. */
     
357. void StepMotor_SetStep(StepMotor_Struct* StepMotor_P, uint32_t step)
     & F6 N- ^* Z. S7 X! U5 w) P/ E
358. {
     2 R6 l4 |; V$ Y' i
359.         StepMotor_P->StepSV = step * StepMotor_P->triggerNum;
     
360.         StepMotor_P->StepCount = StepMotor_P->StepSV;
     - {4 x2 B8 Z# V1 n! X5 Z
361. }
     1 N- v0 h2 P' B. n$ _
362. 
     
363. 
     8 \1 \* t: \! f* x' e3 B
364. /**
     2 U5 A7 k$ U' o1 [
365. * @brief 设置步进电机的工作模式
     
366. * @param StepMotor_P: 步进电机结构体指针
     . {& M6 U8 S. y& b, d4 X7 a  k: X
367. * @param mode: 电机工作模式
     
368. *                 @arg 0: 点动
     
369. *                 @arg 1: 往复
     9 K: O3 }6 z$ g" h+ ~. {
370. *                 @arg 2: 长动
     : k& U+ @: H/ b/ X- L, a* H
371. */
     
372. void StepMotor_SetWorkMode(StepMotor_Struct* StepMotor_P, uint8_t mode)
     : G0 d8 C% q' `, a
373. {
     
374.         StepMotor_P->WorkMode = mode;
     
375. }
     
376. 
     
377. /**
     3 G. q7 x( ]+ c7 Q3 C+ `" Q) d
378. * @brief 设置步进电机的循环次数
     : b& R; }" [. A: \7 o( C3 D
379. * @param StepMotor_P: 步进电机结构体指针
     
380. * @param loopCount: 电机循环次数（仅在工作模式为往复时生效）
     
381. */
     
382. void StepMotor_SetLoopCount(StepMotor_Struct* StepMotor_P, uint32_t loopCount)
     . {% @  O, _- j
383. {
     + ?6 [8 r7 `1 h+ u( ~# s
384.         StepMotor_P->LoopCount = loopCount;
     , A- w5 b0 x4 U6 r) d0 c! x$ D
385. }
     ! m6 C# q+ r% J4 R. Z
386. 
     
387. /**
     
388. * @brief 在定时器的更新中断服务函数中周期性调用此函数
     
389. * @param StepMotor_P: 步进电机结构体指针
       w; s( I" W# \& i* O
390. *                         需要注意的是，传入的步进电机结构体的SetSpeed与SetExec指针所依赖的驱动定时器
     
391. *                         应当与调用本函数的驱动定时器一致，否则会出现错误
     * T" y& ?# {9 `2 s: b
392. */
     + l" Q2 f; L1 K. C
393. void StepMotor_TryMove(StepMotor_Struct* StepMotor_P)
     $ b* z, |4 ?- Z8 }8 ?) ?- ?1 A
394. {
     
395.         //正常工作模式
     7 ?4 K4 h; ^4 L) C
396.         if (StepMotor_P->WorkMode == 0)
     
397.         {
     0 [: w4 X# |& i9 G/ g  y' r9 M
398.                 if (StepMotor_P->StepCount != 0)
     0 w- Z% c- j! S% x- c/ Q
399.                 {
     
400.                         //翻转一次脉冲端口电平
     
401.                         StepMotor_P->SetPulse(2);
     
402.                         StepMotor_P->StepCount--;
     ) j1 W2 v  |0 m4 a9 z5 J( A
403.                 }
     7 [2 g; x( B5 B, y( g/ F
404.                 else
     
405.                 {
     
406.                         //停止步进电机
     ; V8 x9 a8 n9 n2 K
407.                         StepMotor_P->SetExec(0);
     
408.                         StepMotor_P->IsRun = 0;
     0 N6 s$ m. L- F: ^
409.                 }
     
410.         }
     0 \1 D8 n7 x% B  e0 @# F% B
411.         //往复工作模式
     . p; \1 r5 h% [: N; ?
412.         else if (StepMotor_P->WorkMode == 1)
     
413.         {
     
414.                 if (StepMotor_P->LoopCount != 0)
     7 d: m, q9 e, S( k
415.                 {
     7 f0 h+ Y: k3 G4 s* q7 B2 T
416.                         if (StepMotor_P->StepCount != 0)
     
417.                         {
     ' d" S3 Z' M4 O; z& R! T$ g8 u
418.                                 StepMotor_P->SetPulse(2);
     
419.                                 StepMotor_P->StepCount--;
     
420.                         }
     
421.                         else
     
422.                         {
     
423.                                 StepMotor_P->LoopCount--;
     
424.                                 StepMotor_P->StepCount = StepMotor_P->StepSV;
     
425.                                 //翻转方向
     4 t8 o  y6 Y! C1 i1 q3 P& s7 H; f- p
426.                                 StepMotor_P->SetDir(2);
     : B+ n! |- h: }1 n2 W
427.                         }
     # |$ W4 C, d0 |3 n' ], c3 o7 M: p
428.                 }
     + I, N* d) w" S0 g' p$ u
429.                 else
     / h1 S% x- N4 \  O" z" L4 c' y
430.                 {
     
431.                         StepMotor_P->SetExec(0);
     2 U" R$ ~/ v6 u9 W4 o/ C; ]
432.                         StepMotor_P->IsRun = 0;
     " Y  ^: x% j/ B; d, G) n
433.                 }
     
434.         }
     ) `5 u3 I: O$ d: D
435.         //连续工作模式
       A) P! Z  m" A& U+ e/ p" \
436.         else if (StepMotor_P->WorkMode == 2)
     - ]% O, v+ e( v- m
437.         {
     
438.                 //翻转一次脉冲端口电平
     " _- K+ A, |: A; i) U
439.                 StepMotor_P->SetPulse(2);
     
440.         }
     
441.         else
     
442.         {
     
443. 
     - O$ k) h: M$ `! M
444.         }
     ! L$ V6 F6 W& R" L2 O$ f* Q
445. }
     
446. 
     - n# x) w* x& T8 _) h
447. 
     
448. #endif
     

复制代码

应用指南
根据硬件平台实现结构体成员中的各函数指针（SetState_FP SetEn,SetState_FP SetDir,SetState_FP SetPulse,SetParam_FP SetSpeed,SetState_FP SetExec,）的回调函数。这些回调函数或是操作GPIO的电平输出，或者控制着硬件定时器的频率与启停。以STM32F103平台为例：
- O, A. B. _6 X! {% `5 `+ H

1. //SetEn的回调函数
   
2. static void StepMotor_1_SetEn_Handler(uint8_t state)
   8 H: w5 h5 J' Y, U( F
3. {
   
4.         STEPMOTOR_1_EN = state;
   
5. }
   $ P2 f! e/ E1 f
6. 
   
7. //SetDir的回调函数
   ) \7 [: O0 o& ~4 o1 ]1 @) @
8. static void StepMotor_1_SetDir_Handler(uint8_t state)
   6 Z" N1 {/ Z1 O5 ?) y* \
9. {
   
10.         if(state < 2)
    
11.         {
    
12.                 STEPMOTOR_1_DIR = state;
    
13.         }
    
14.         else
    
15.         {
    3 I* V& k0 B* ^, R6 z$ I
16.                 STEPMOTOR_1_DIR = ~STEPMOTOR_1_DIR;
    
17.         }
    
18. }
    
19. 
    - Y' B5 C0 _/ `( H
20. //SetPulse的回调函数
    
21. static void StepMotor_1_SetPulse_Handler(uint8_t state)
    " Y% N$ \1 i. P1 N4 C: _
22. {
    
23.         if(state < 2)
    ( c' ]7 F! p: ^0 ^6 x8 w9 k9 E: N
24.         {
    $ z4 I0 W  y3 f) T$ O1 N- {
25.                 STEPMOTOR_1_PUL = state;
    ' }3 Y1 P' p1 Y7 k
26.         }
    
27.         else
    . {1 L2 g  y$ x  K( [/ R9 a8 i
28.         {
    
29.                 STEPMOTOR_1_PUL = ~STEPMOTOR_1_PUL;
    
30.         }
    
31. }
    
32. 
    
33. //SetSpeed的回调函数
    " C/ Z& F# J8 s0 Y% q8 c; [
34. static void StepMotor_1_SetSpeed_Handler(uint32_t speed)
    
35. {
    & @% {3 e/ x# W. m& h0 p# Z
36.         speed = speed * StepMotor[0].triggerNum;
    
37. 
      W$ f0 N% ^  j# x; R
38.         //frequency < 1k, psc = 7200
    ' E# H! A% @, m4 k
39.         if (speed < 1000)
    
40.         {
    
41.                 TIM5->PSC = 7200 - 1;
    8 E1 a2 d+ H" b1 G% W9 j
42.         }
    
43.         //frequency < 10k, psc = 720
    7 C7 X9 H4 g( k
44.         else if (speed < 10000)
    
45.         {
    
46.                 TIM5->PSC = 720 - 1;
    
47.         }
    
48.         else
    
49.         {
    
50.                 return;
    0 B- F) l, w7 O' P/ f
51.         }
    
52. 
    ' w1 U& n0 k1 }
53.         //Set the update frequency of the timer.
    # C7 q2 i' a$ y' x
54.         TIM5->ARR = 72000000.0 / (TIM5->PSC + 1) / speed - 1;
    1 k; l2 e) N0 P* R- q% t0 n
55. 
    , |. v8 R  N1 [4 E$ y
56.         return;
    
57. }
    
58. 
    0 Z3 u7 c! ~- K: V! D
59. //SetExec的回调函数
    
60. static void StepMotor_1_SetExec_Handler(uint8_t state)
    
61. {
    # j$ n$ {5 ]3 T& F) O
62.         TIM_Cmd(TIM5, state);
    
63. }
    

复制代码

初始化步进电机结构体变量（数组）。可以在声明时直接将结构体变量（数组）进行初始化，也可以利用void StepMotor_Init()函数实现结构体变量（数组）的初始化。

1. StepMotor_Struct StepMotor[SETPMOTOR_NUM] =
   - E( g/ E3 y! e7 v4 A* a4 k3 o0 A
2. {
   
3.                 //Initialization of step motor 1
   1 d9 _- L- Q9 m
4.                 {
   
5.                                 .IsRun = 0,
   
6.                                 .triggerNum = 2,
   
7.                                 .StepCount = 0,
   
8.                                 .LoopCount = 0,
   , a4 q7 g' v; _) f7 G# I3 C
9.                                 .StepSV = 100,
   " @" e" D% c; g' f- C
10.                                 .WorkMode = 0,
    0 e: n4 J1 z9 Y6 [
11. 
    * G" N$ M" k  ?5 q; X: a
12.                                 .SetEn = StepMotor_1_SetEn_Handler,
    7 M" x2 P5 L3 \( D9 s' D+ t& y6 G3 u# b
13.                                 .SetDir = StepMotor_1_SetDir_Handler,
    
14.                                 .SetPulse = StepMotor_1_SetPulse_Handler,
    
15.                                 .SetSpeed = StepMotor_1_SetSpeed_Handler,
    
16.                                 .SetExec = StepMotor_1_SetExec_Handler,
    
17.                 },
    
18. 
    
19.                 //Initialization of step motor 2
    
20.                 {
    3 n$ Q; O  Z% m* x! {9 l( F7 O
21.                                 .IsRun = 0,
    ( F, ?4 x, D- X* v
22.                                 .triggerNum = 2,
    
23.                                 .StepCount = 0,
    * p1 n" X" _7 X0 y0 }, t! q
24.                                 .LoopCount = 0,
    8 V" X  G0 B" q; {5 S
25.                                 .StepSV = 100,
    / f! ~2 c2 c9 {2 p9 H% [' `2 [! \
26.                                 .WorkMode = 0,
    
27. 
    . c% B$ b, _, e/ S4 V8 ]% L
28.                                 .SetEn = StepMotor_2_SetEn_Handler,
    
29.                                 .SetDir = StepMotor_2_SetDir_Handler,
    
30.                                 .SetPulse = StepMotor_2_SetPulse_Handler,
    , }- f- H7 `& P; h) V5 J  }0 n! h
31.                                 .SetSpeed = StepMotor_2_SetSpeed_Handler,
    
32.                                 .SetExec = StepMotor_2_SetExec_Handler,
    
33.                 },
    ! O0 f: n/ |- |' {; G* \
34. 
    
35.                 //Initialization of step motor 3
    
36.                 {
    ; t. @$ |/ ^6 B+ K
37.                                 .IsRun = 0,
    
38.                                 .triggerNum = 2,
    
39.                                 .StepCount = 0,
    
40.                                 .LoopCount = 0,
    
41.                                 .StepSV = 100,
    / z6 f# r( l9 w. N! W) J2 j
42.                                 .WorkMode = 0,
    / ?% j) e9 w3 X
43. 
    8 ?& O# M' k# `! {' j( O. y
44.                                 .SetEn = StepMotor_3_SetEn_Handler,
    
45.                                 .SetDir = StepMotor_3_SetDir_Handler,
    
46.                                 .SetPulse = StepMotor_3_SetPulse_Handler,
    
47.                                 .SetSpeed = StepMotor_3_SetSpeed_Handler,
    7 J) I3 O- h. L
48.                                 .SetExec = StepMotor_3_SetExec_Handler,
    
49.                 },
    
50. 
    7 ^* @6 }- W0 h5 `# }# _8 ^7 q% L; j
51.                 //Initialization of step motor 4
    * _+ @8 g1 o+ Q# C% ?" r
52.                 {
    ( r2 Y5 m5 a3 I* U7 u2 `3 {! o# r% P
53.                                 .IsRun = 0,
    0 b1 L! L1 l, n7 {# h
54.                                 .triggerNum = 2,
    
55.                                 .StepCount = 0,
    % Z0 l8 E9 l; J4 L
56.                                 .LoopCount = 0,
    
57.                                 .StepSV = 100,
    
58.                                 .WorkMode = 0,
    3 f- Z+ K) |$ q# d* e" f& d1 C
59. 
    * h6 b$ ^- i+ ~' H, B/ D' D
60.                                 .SetEn = StepMotor_4_SetEn_Handler,
    ' q" A, T: {5 V
61.                                 .SetDir = StepMotor_4_SetDir_Handler,
    
62.                                 .SetPulse = StepMotor_4_SetPulse_Handler,
    
63.                                 .SetSpeed = StepMotor_4_SetSpeed_Handler,
    6 }1 T7 J  @* y0 {6 H
64.                                 .SetExec = StepMotor_4_SetExec_Handler,
    7 e4 t( ^6 l- z0 i7 |0 e
65.                 },
    
66. };

复制代码

& i! @- ]$ T# @  P6 D在项目工程的合适位置配置控制功能的回调函数中所依赖的定时器，并配置定时器的更新中断

1. void Timer_Config()
   / V7 s, f7 E" o) B, \3 c: t7 M$ j
2. {
   
3.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
   % Z, p+ p7 a$ Y5 f0 F
4. 
   ' Z. u. t- T( y; e2 d
5.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);
   0 |- _6 _- S$ g+ c
6. 
   
7.         TIM_DeInit(TIM5);
   
8.         TIM_TimeBaseInitStructure.TIM_Prescaler = TIM5_Prescaler - 1;
   
9.         TIM_TimeBaseInitStructure.TIM_Period = TIM5_Period - 1;
   ( O, e3 k: \$ A
10.         TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    
11.         TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
12.         TIM_TimeBaseInit(TIM5, &TIM_TimeBaseInitStructure);
    4 I" J8 g' ]$ V+ K: h1 U- z' B
13.         
    
14.         TIM_ClearFlag(TIM5, TIM_FLAG_Update);
    
15.         TIM_ITConfig(TIM5, TIM_IT_Update, ENABLE);
    % f: K7 u* w9 ^9 N# X' X3 w' \9 N
16.         //        TIM_ARRPreloadConfig(TIM5, ENABLE);
    
17. }
    4 S! S1 z7 z7 o$ _
18. 
    7 v2 Z# F+ Z, T" M0 \" e
19. 
    5 @9 c* _4 n/ |2 {
20. void NVIC_Config()
    , I% t% Y- Q: A- C+ ^+ R3 n
21. {
    7 V# `; d: @0 g! b. M9 @2 y3 i  R
22.         NVIC_InitTypeDef NVIC_InitStructure;
    
23.         
    ; Y! v+ _) q1 }( ^! ]
24.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    * P% d; m" h8 k7 K0 A5 X0 d+ R5 {% e
25. 
    7 ~# R7 ~8 n4 ^, [( _2 K
26.         //Timer5 is used for drive step motor 1.
    
27.         NVIC_InitStructure.NVIC_IRQChannel = TIM5_IRQn;
    
28.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
    7 r! N7 n$ g" y) Q# Q- z
29.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    . u; N! g" Q6 u7 e; E) V
30.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
31.         NVIC_Init(&NVIC_InitStructure);
    
32. }

复制代码

在定时器的更新中断服务函数中调用void StepMotor_TryMove(StepMotor_Struct* StepMotor_P)。
4 g6 t# T5 w% w) \* E, D

1. void TIM5_IRQHandler(void)
   % e- r2 u0 O( C/ W/ Q' ^2 {9 `
2. {
   - A7 Q" n5 o* J
3.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)!=RESET)
   : C/ B1 _6 x& `2 n! Y: }3 ~. [/ f
4.         {
   4 c7 w- n; r8 ?$ b5 P
5.                 StepMotor_TryMove(&StepMotor[0]);
     ]( u3 g0 h: H$ N' s4 h* u3 F2 n
6.                
   ! e2 g" ]! L: K( G5 Z4 Y' R
7.                 TIM_ClearFlag(TIM5,TIM_FLAG_Update);
   ; Y* H& m/ m: C0 I) _/ L0 ?2 f+ t' j
8.                 TIM_ClearITPendingBit(TIM5,TIM_IT_Update);
   0 @! Z. [- ^) }* R  @9 r
9.         }
   , H. A3 [" u9 V  }* z
10. }

复制代码

. D6 k7 L/ b1 e设置电机的启动参数并启动电机。

1. void StepMotor_RunM1(void)
   & w# C0 z( R5 m8 D9 c  I
2. {
   
3.         //设置运动参数
   9 K+ d4 @$ r" |( e! c5 D
4.         StepMotor_SetStep(&StepMotor[0], 1200);
   
5.         StepMotor_SetWorkMode(&StepMotor[0], 1);
   
6.         StepMotor_SetLoopCount(&StepMotor[0], 50);
   4 J# `0 e) L& K4 l
7.         StepMotor[0].SetSpeed(3000);
   & H/ P8 ^; m( }- ~  f$ N3 o
8. 
   5 G3 N& J7 o5 O+ I5 q: R& d: ^7 W
9.         //启动电机并设置标志位
   8 h( d5 P9 \! U, l- w; y
10.         StepMotor[0].SetExec(1);
    9 c' z( F) c  N9 q8 a4 M: Y$ y+ t+ J1 K
11.         StepMotor[0].IsRun = 1;
    4 {  ]6 c" @0 I! g) D# o. g
12. }

复制代码

停止电机，一般在光电对管触发的外部中断服务函数中调用。

1. void StepMotor_StopM1(void)
   5 @4 s6 v1 U5 u- |6 c7 i4 Z
2. {
   
3.         //停止电机并设置标志位
   & K  m8 Y9 v1 \- M, g7 k, c& D( p
4.         StepMotor[0].SetExec(0);
   
5.         StepMotor[0].IsRun = 0;
   
6.         StepMotor[0].StepCount = 0;
   $ }# ?  F8 S( K  n
7. }

复制代码

特别说明1：在光电对管触发的外部中断服务函数中调用停止电机函数时，应当注意软件滤波消除抖动，也可以适当延时后再关闭电机以摆脱光电对管触发的临界点位置。

1. void EXTI0_IRQHandler(void)
   5 M, j6 k5 @8 [* N; ?; r
2. {
   - t" n: Y) f, c5 u! M6 N8 R
3.         if (EXTI_GetITStatus(EXTI_Line0) != RESET)
   
4.         {
   
5.                 //延时以消除抖动
   . H$ |/ D7 g8 g
6.                 delay_ms(10);
   6 x& ~9 B- x7 S  n- F2 ^
7.                
   
8.                 if(MOTOR_LIMIT_SWITCH_1_1 == 0)
   
9.                 {
   # l# g5 t5 V5 C0 e4 L1 K' E
10.                         //Stop motor 1
    7 R% g3 \# \7 j  j. Z3 ?
11.                         StepMotor[0].SetExec(0);
    9 }4 _9 Y; ~+ g9 `
12.                         StepMotor[0].IsRun = 0;
    
13.                         StepMotor[0].StepCount = 0;
    : K+ G6 V& h4 a
14.                 }
    , ~6 S, X$ ]1 u3 ^. {
15.                
    ( a2 j# k4 Z. b# W: ^
16.                 EXTI_ClearITPendingBit(EXTI_Line0);
    
17.         }
    
18. }

复制代码

特别说明2：触发光电对管后，电机再启动需要有方向保护，不能继续向原方向运动，否则会由于光电对管无法再次被触发而导致电机失控。可以在控制电机启停的业务代码中增加对光电对管状态的判断：
4 e3 k( _# N+ Z6 o+ C2 z

1. void StepMotor_RunM1(void)
   
2. {
   
3.         //设置运动参数
   ; `5 M) @: h, [) O$ S+ H3 T
4.         StepMotor_SetStep(&StepMotor[0], 1200);
   3 S1 F2 c5 r. a' b. Y+ S% N
5.         StepMotor_SetWorkMode(&StepMotor[0], 1);
   4 g7 Y5 s6 I9 q( W
6.         StepMotor_SetLoopCount(&StepMotor[0], 50);
   8 {+ ^2 J$ V  Z( M' ?7 }8 [
7.         StepMotor[0].SetSpeed(3000);
   
8. 
   7 [& S2 `, S7 U2 t* c6 T$ _2 N$ `
9.         if((MOTOR_LIMIT_SWITCH_1_1 ==0) &&(STEPMOTOR_1_DIR == 0))
   
10.         {
    1 L+ A' y; _' A6 X( m
11.                 return;
    
12.         }
    
13.         else if((MOTOR_LIMIT_SWITCH_1_2 ==0) &&(STEPMOTOR_1_DIR == 1))
    ) C2 O' \$ \( v" O# N% o" A
14.         {
    $ s1 ?' f4 p; O4 S  ?* s
15.                 return;
    
16.         }
    
17.         else
    4 V' c( J  \# y/ G: K
18.         {
    
19.                 //启动电机并设置标志位
    1 `) `" Z  I6 T, B* K$ U' {
20.                 StepMotor[0].SetExec(1);
    
21.                 StepMotor[0].IsRun = 1;
    + `6 `4 r: |7 Q" s, h7 A
22.         }
    
23. }

复制代码

. f1 i% U# u$ i: @5 b8 k2 |
( s- [9 C( q  ]2 h9 u. z
  X) O) E. K3 r8 c/ l