stm32f103c8t6控制多个步进电机
关于两相步进电机的详细内容，相信在网上一大堆可以找得到，这里我主要介绍的是实践部分。
2 v4 P& Y4 [# G, s首先，我们需要认清步进电机的四根线，一般来说四根线颜色基本都为红、蓝、绿、黑，对应的分别是A+，A-，B+，B-，一些步进电机上面会标哪根线对应哪个相，比如我用的步进电机是这款的
6 m% Z5 h8 Q5 z& t1 w

  f) ]' d/ C6 C0 v

# s, y( n! n' V- ?7 L8 J

其实哪款步进电机都无所谓，原理都是差不多的，主要看电机的电流是否满足步进电机驱动器的要求。
) d- x; |. v3 D# W7 [+ h我用的步进电机驱动器是以下这款，之所以用这款是因为这款步进电机驱动器体积相对比较小并且满足要求，从上面我们可以看到我上面的步进电机的工作电流是2.3A，而从步进电机驱动器的面板上面可以看出他最大可以工作在3A电流。
8 s# ~! E# Y% ^  R( j* R

4 D5 E& o1 Q- C& `
驱动器面板上面的STOP是指控制脉冲信号停止施加 0.5 秒左右，会自动进入半电流状态，这时电机相电流为运行时的 50%，以降低功耗减少电机发热，收到新的控制脉冲后驱动器自动退出半电流状态， 此功能 一直有效。一般都是设置50%，也就是半电流状态。
; ?  I) Z' q9 M, H* Y% u9 B驱动器面板上面的Decay Setting是衰减设置，一般设置成0%即可。
驱动器面板上面的Excitation Mode是细分设置，原本发出一个脉冲步进电机转动1.8°，如果细分为2的话，步进电机转动0.9°。有些驱动板上面写着200、400、800、1600、3200等等，是指转动一圈所需要的脉冲数。
, p6 G8 S6 m. ?驱动器和两相混合式步进电机的连接采用四线制，电机的绕组有并联和串联接法，并联接法，高速性能好，但驱动电流大；串联接法适用于高力矩输出。一般的，高速输出的接线方式其输出电流设定在电机额定电流的 1.4 倍；高力矩输出的接线方式其输出电流设定在电机额定电流的 70%。
我采用的是共阴极接法，程序也会是共阴极的。
程序中stm32与步进电机驱动器接线如下
5 S" m- o+ {3 A$ c5 F: s( l/ p
/*
  u8 \- f6 S% v2 P6 q$ H! r. Z步进电机1
2 }7 ]) F6 j! n6 s7 i. ~Pluse±>PA.1，Pluse-接GND
0 E' h  U9 S! @' j: \' k  xDIR±>PA.8，DIR-接GND
1 A! @3 g7 e  B7 |EN±>PA.11，EN-接GND
步进电机2
0 |* Y6 A) d* w& SPluse±>PA.7，Pluse-接GND
# m4 A" [  l( n5 R% q2 qDIR±>PA.6，DIR-接GND
/ v- K% s3 n: [' S, A! ?EN±>PA.5，EN-接GND
*/

接下来附上相关程序，程序后面都有注释，个人认为这个注释已经很仔细了
主函数如下：
0 U3 b9 ]8 U' Y

1. #include "delay.h"
   / _$ y" X4 _( p8 O7 ^2 X& f: [5 ~
2. #include "key.h"
   . D: m9 o. b$ B4 k" q) R& g
3. #include "led.h"         
   3 e2 F) c9 |/ `) i0 }, b
4. #include "usmart.h"        
   3 c$ _: B" C# s  ^: {, x. g" J1 \
5. #include "driver.h"
   7 r$ t; q4 I! s. q) j; y
6. 
   % k  {, O8 v. G& w0 E* v
7. /*
   ( t: K: F4 B4 G# g* p
8. 步进电机1，由按键PA.0控制
   6 e1 o+ D5 n' c5 J
9. Pluse+->PA.1，Pluse-接GND
   
10. DIR+->PA.8，DIR-接GND
    & l2 V/ N* r6 Q" H4 }
11. EN+->PA.11，EN-接GND
      F$ s* n; E  }; R  A% D
12. 步进电机2，由按键PA.4控制
    
13. Pluse+->PA.7，Pluse-接GND
    # T" j0 f4 o. b1 ?
14. DIR+->PA.6，DIR-接GND
    + f& M) w& Z' R3 `: ^% g
15. EN+->PA.5，EN-接GND
    ' l5 U* X4 k' W
16. */
    9 y& I* Y  o* S4 S! G
17. 
    
18. int main(void)
    1 }& p! e* p+ Q. ]
19. {         
    
20.         u8 keyval;
    7 y5 |) d9 L& l1 q- _
21.         delay_init();                        //延时函数初始化         
      a9 ~: j" V# }% k1 t# q  S7 M# x
22.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);          //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    
23.         uart_init(115200);                     //串口初始化为115200
    
24.         KEY_Init();                                        //初始化按键
    
25.         Driver_Init();                            //驱动器初始化
    $ O" f* j3 ?+ ?6 k* ]' @+ C
26.         TIM2_Init(999,72-1);        //1MHz计数频率,第一个参数自动装载值在后面TIM2_Startup函数中会被改变
    
27.         TIM3_Init(999,72-1);
    
28.         while(1)
    : X8 c0 Q" A& Y  `
29.         {        
    / b( {* u7 j' ^2 l
30.                 keyval=KEY_Scan(0);
    
31.                 if(keyval==WKUP_PRES)
    ; k& Z) E4 }# O% b" V
32.                 {
    % U& a" Y$ f  K4 T' w; s  l9 v
33.                         Locate_Rle2(500,CW);//500的意思你点进去看函数就明白了，大概就是重新设置定时器自动重装载值，让PWM一半高电平，一半低电平。
    : W8 x: }3 d+ I. r
34.                         Locate_Rle3(500,CW);
    : r5 I# a& h# E$ N
35.                 }
    
36.                 if(keyval==KEY0_PRES)
    
37.                 {
    4 l" N, P& ?7 u& s+ b' [1 U  D( `
38.                         Locate_Rle2(500,CCW);
    
39.                         Locate_Rle3(500,CCW);
    
40.                 }
    8 m7 z9 F& g9 P( L: I0 x2 y
41. 
    : @. P5 E' Z/ {/ k2 k; l2 s
42.         }                        
    7 C  g) L  i& i
43. }
    
44. 
    

复制代码

两个定时器初始化以及中断函数等等

' V- b! p8 h; r9 V# ~+ n) Q% W5 n

1. #include "driver.h"
   4 m% M: d# X5 l& d! i
2. #include "delay.h"
   
3. #include "usart.h"
   
4. 
   
5. long current_pos[2]={0,0}; //有符号方向
   
6. DIR_Type motor_dir2=0;
   
7. DIR_Type motor_dir3=0;
   
8. u8 count[2]={0,0};
   
9. /************** 驱动器控制信号线初始化 ****************/
   3 n9 z6 {+ m9 @9 ?
10. void Driver_Init(void)
    
11. {
    
12.         GPIO_InitTypeDef  GPIO_InitStructure;
    6 Y8 h7 I9 W3 V8 B: W
13. 
    1 L' _5 ?3 P, u
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        //使能PA端口时钟
    ! x- N/ V4 \; l7 E6 s2 j6 u1 U
15. 
    ' K! V* h5 l/ W
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_5|GPIO_Pin_8|GPIO_Pin_11;        //PC0.2 端口配置
    ' N7 L6 y$ n4 n1 @% {1 |' ?
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 //推挽输出
    
18.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                //IO口速度为50MHz
    + e1 e5 p: ?$ Y: a' l  K
19.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                        //根据设定参数初始化GPIOA
    
20.         GPIO_SetBits(GPIOA,GPIO_Pin_6);                                                         //PA6输出高 顺时针方向  DRIVER_DIR
    4 }! {% G& r! S) ^& J
21.         GPIO_ResetBits(GPIOA,GPIO_Pin_5);                                                //PA5输出低 使能输出  DRIVER_OE
    
22.         GPIO_SetBits(GPIOA,GPIO_Pin_8);                                                         //PA8输出高 顺时针方向  DRIVER_DIR
    9 y9 t, n9 m- R  L/ H; r- _* X( \, }
23.         GPIO_ResetBits(GPIOA,GPIO_Pin_11);                                                //PA11输出低 使能输出  DRIVER_OE
    
24. }
    
25. 
    % D0 a# B3 ]3 K" [# \: U( M
26. /***********************************************
    
27. //TIM2_CH2(PA1) 单脉冲输出+重复计数功能初始化
    ; H  ^" T) h8 H3 M; ~' \, f
28. //TIM2 时钟频率 72MHz
    
29. //arr：自动重装值
    
30. //psc：时钟预分频数
    ; ]' Y$ v* ~4 `( r0 D6 \/ H5 J
31. ************************************************/
    : H, h. J# T( A( O, L5 p
32. void TIM2_Init(u16 arr,u16 psc)
    
33. {                                                         
    * D2 P0 t) u; _; T  f2 c3 U. `
34.         GPIO_InitTypeDef GPIO_InitStructure;
    4 T) Y7 I4 U# _7 v' t
35.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    ( A9 l4 L, y& }) t6 p! M+ P  p3 v
36.         TIM_OCInitTypeDef  TIM_OCInitStructure;
    
37.         NVIC_InitTypeDef NVIC_InitStructure;
    + |0 s% V& V& {" U. z2 k
38. 
    4 X, h& Z1 v6 |- h  F1 d
39.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);         //TIM2时钟使能
    
40.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);  //使能GPIOA外设时钟使能                                                                                    
    $ V% M' e1 q2 T* M
41. 
    
42.   //设置该引脚为复用输出功能,输出TIM2 CH2的PWM脉冲波形
      x7 m9 I# _/ v/ m# ~1 h
43.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                                //TIM2_CH2
    
44.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                        //复用推挽输出
    8 `# f" Z2 d  D0 ]
45.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    6 D) m" Q$ d! b& V0 t
46.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    ! Z; ]8 d4 o" j% i1 U
47.         
    
48.         TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
    5 A8 V7 a3 ]3 @7 w: ]; s0 ]5 F
49.         
    4 R1 D3 A7 m* H8 I0 `
50.         TIM_TimeBaseStructure.TIM_Period = arr;                                        //设置在下一个更新事件装入活动的自动重装载寄存器周期的值,设置计数到这个值就产生溢出         
    
51.         TIM_TimeBaseStructure.TIM_Prescaler =psc;                                //设置用来作为TIMx时钟频率除数的预分频值  
    
52.         TIM_TimeBaseStructure.TIM_ClockDivision = 0;                         //设置时钟分割:TDTS = Tck_tim,是改变作输入捕获时滤波用的并不是定时器的分频器
    % R5 V  `9 s/ e# r9 R# Z1 T
53.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //TIM向上计数模式
    
54.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);                 //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
    
55.         TIM_ClearITPendingBit(TIM2,TIM_IT_Update);                                //清除的是一些中断标志位
    
56. 
    ( G+ O* F$ L# c5 J* w: G: T
57.         TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Regular); //TIM_UpdateSource_Regular 生成单一的脉冲：计数器在下一个更新事件停止，即关闭   
    
58.         TIM_SelectOnePulseMode(TIM2,TIM_OPMode_Single);                        //单脉冲模式
    ' u/ n* f4 N+ _2 F6 j
59. 
    4 \" u' B6 X& X# s$ s
60.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;                //选择定时器模式:TIM脉冲宽度调制模式2[1]
    % \' T5 S  n7 c& v. W& ^. K) n
61.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //比较输出2使能
    : `, v% M) N! F
62.         TIM_OCInitStructure.TIM_Pulse = arr>>1;                                 //设置待装入捕获比较寄存器的脉冲值
    ! L8 X4 c% e9 h; g. }+ p* U# s
63.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; //输出极性:TIM输出比较极性高[2]
    1 p6 y7 b3 B7 A: E% P. a) ?  P4 e
64.         //----[1][2]这两个配合一起然后查手册可以得到->当计时器值小于比较器设定值时则TIMX输出脚此时输出有效低电位。
    
65.         TIM_OC2Init(TIM2, &TIM_OCInitStructure);                                 //根据TIM_OCInitStruct中指定的参数初始化外设TIMx
    * e; q1 r2 D* S0 q& t5 X! D, A
66. 
    
67.         TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);                  //CH2预装载使能         
    
68.         TIM_ARRPreloadConfig(TIM2, ENABLE);                                         //使能TIMx在ARR上的预装载寄存器
    
69.         
    
70.         TIM_ITConfig(TIM2, TIM_IT_Update ,ENABLE);                          //TIM2使能或者失能指定的TIM中断
    
71. 
    * C0 ^% M! ]. X4 k
72.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                  //TIM2中断
    ) U. U7 I+ l/ b7 n8 U
73.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级0级
    
74.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                 //从优先级0级
    
75.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                 //IRQ通道被使能
    
76.         NVIC_Init(&NVIC_InitStructure);                                                  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    , P* H2 y4 O  y1 B8 h0 _$ w" Q, E: Z' ^
77.         
    9 V- t) C4 Q% U5 _. W9 {3 b+ k3 r
78.         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);                          //清除TIMx的中断待处理位:TIM 中断源
    / I0 m9 r5 d$ n) l* P0 s
79.         TIM_Cmd(TIM2, DISABLE);                                                                  //使能TIM2                                                                          
    / Z2 m7 k/ K* I% T5 z5 {: r4 {+ m
80. }
    
81. /******* TIM2更新中断服务程序 *********/
    
82. void TIM2_IRQHandler(void)
    
83. {
    
84.         if(TIM_GetITStatus(TIM2,TIM_FLAG_Update)!=RESET)//更新中断
    / F0 z9 S3 [7 p* d0 [% u
85.         {
    
86.                 TIM_ClearITPendingBit(TIM2,TIM_FLAG_Update);//清除更新中断标志位               
    9 q' [4 k' T) [& y
87.                 count[0]++;
    - K2 q, G, I* ^3 s
88.                 TIM_GenerateEvent(TIM2,TIM_EventSource_Update);//产生一个更新事件 重新初始化计数器，
    
89.                 //这里产生一个脉冲送到步进电机让电机运转一个脉冲数，即不细分的情况下，一般步进电机转1.8°
    
90.                 //定时器初始化中，设置单脉冲模式是让计数器在下一个更新事件停止，即关闭，防止这次中断还没结束，
    
91.                 //下一个计数器时间已经到了使中断紊乱，也就是进入中断后，定时器自动关闭。                        
    % R$ v  _# q7 X, K: K0 A' T/ M
92.                 TIM_Cmd(TIM2, ENABLE);                                             //使能TIM2,让定时器开始下一个脉冲计数后输出        
    
93.                 if(count[0]==200)
    
94.                 {
    % _+ x! Z+ a# \. o0 x) }5 g$ z% Z
95.                         if(motor_dir2==CW)                                                    //如果方向为顺时针   
    
96.                                 current_pos[0]+=count[0];
    
97.                         else                                                                     //否则方向为逆时针
    
98.                                 current_pos[0]-=count[0];
    2 D+ B2 E7 U& o; q, d: r$ N$ I
99.                         TIM_Cmd(TIM2, DISABLE);                                     //关闭TIM2                        
    
100.                         printf("motor2当前位置=%ld\r\n",current_pos[0]);//打印输出
     
101.                         count[0]=0;
     
102.                 }
     
103.         
     
104.         }
     
105. }
     , f- }; D$ I; ?5 y7 k! m
106. 
     8 X; w3 i- ]2 h; C- f
107. void TIM3_Init(u16 arr,u16 psc)
       W0 e$ u) Z# d( E$ Q
108. {                                                         
     
109.         GPIO_InitTypeDef GPIO_InitStructure;
     
110.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     . _0 {5 F  p( `, F) ~! v6 k
111.         TIM_OCInitTypeDef  TIM_OCInitStructure;
     , V4 U( y6 g1 M
112.         NVIC_InitTypeDef NVIC_InitStructure;
     ! w4 G# a3 O4 P% k; N- E) K
113. 
     + ?4 W/ U- S! c" d# K" Q9 I4 T
114.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
     7 i5 N( c% {) a0 d8 b6 u" F. F
115.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);                                                                                       
     
116. 
     7 h0 ]" y; S$ o8 M* I
117. 
     
118.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
     ! s; [6 d" |/ V
119.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  
     ' {7 c+ p: x$ y9 _
120.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
121.         GPIO_Init(GPIOA, &GPIO_InitStructure);
     
122.         
     
123.         TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
     / B* l+ c$ C5 b0 F# ?/ k
124.         
     8 h0 M- a2 j( {- |
125.         TIM_TimeBaseStructure.TIM_Period = arr;         
     1 F/ `5 r& _$ o8 B
126.         TIM_TimeBaseStructure.TIM_Prescaler =psc;  
     
127.         TIM_TimeBaseStructure.TIM_ClockDivision = 0;
     0 Y1 s, _. O3 m7 J2 u0 N4 r. F7 J
128.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
     
129.         TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
     2 i( b# P4 y, K) a& C
130.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);
     5 f' a& u- l1 r  F; X! G; {
131. 
     , p% u9 K) z/ X9 F% i, C3 t0 z
132.         TIM_UpdateRequestConfig(TIM3,TIM_UpdateSource_Regular);
     1 v( B0 _* O6 r3 i( Z5 A; ~, N
133.         TIM_SelectOnePulseMode(TIM3,TIM_OPMode_Single);
     $ n4 D' T1 B: }$ @1 ^( y6 Q
134. 
     
135.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
     . L7 U# R; I, C0 m9 ?+ k( [! l
136.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
     . J3 m  r! w* k) L
137.         TIM_OCInitStructure.TIM_Pulse = arr>>1;
     
138.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
     
139.         TIM_OC2Init(TIM3, &TIM_OCInitStructure);  
     
140. 
     
141.         TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);           
     9 V" M% x/ J6 o
142.         TIM_ARRPreloadConfig(TIM3, ENABLE);
     3 c1 }1 C3 X/ m6 b
143.         
     
144.         TIM_ITConfig(TIM3, TIM_IT_Update ,ENABLE);  
     
145. 
     1 o4 S' f8 T, }7 A3 ?
146.         NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  
     ) N1 F& f' L4 G
147.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
     
148.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
     + b' y3 `. T3 F
149.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
150.         NVIC_Init(&NVIC_InitStructure);  
     $ C7 g! W  S4 b/ Y2 P
151.         
     
152.         TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
     
153.         TIM_Cmd(TIM3, DISABLE);                                                            
     1 T  U' @" B+ d
154. }
     . ]! m* G6 f9 R' D- ]0 T4 U! k
155. 
     
156. void TIM3_IRQHandler(void)
     6 i* t6 |/ t- u) W6 Y/ U2 P
157. {
     
158.         if(TIM_GetITStatus(TIM3,TIM_FLAG_Update)!=RESET)
     6 A7 a. n" W2 k2 I6 w: j4 g5 P) F
159.         {
     * q8 w) T- C7 H
160.                 TIM_ClearITPendingBit(TIM3,TIM_FLAG_Update);        
     ) [# j* X, r( B$ _5 N/ ?! K: s3 p
161.                 count[1]++;
     
162.                 TIM_GenerateEvent(TIM3,TIM_EventSource_Update);
     8 a! Q' s& a  M1 Y1 U) m+ ^
163.                 TIM_Cmd(TIM3, ENABLE);                  
     2 [; h4 K1 A" W$ ]; z0 z
164.                
     
165.                 if(count[1]==200)
     : c' ^+ ^- |# g  a0 v4 R
166.                 {
     
167.                         if(motor_dir3==CW)                                                 //如果方向为顺时针   
     ) \2 V9 R) y7 |- g- |' |; M  Q
168.                                 current_pos[1]+=count[1];
     
169.                         else                                                                  //否则方向为逆时针
     # p; q! {) g" f7 \4 M% s- s' r; L
170.                                 current_pos[1]-=count[1];
     
171.                         TIM_Cmd(TIM3, DISABLE);                                 
     
172.                         printf("motor3当前位置=%ld\r\n",current_pos[1]);
     5 s( }) \. y$ d* R# s3 f
173.                         count[1]=0;
     
174.                 }        
     
175.         }
     ; I( n3 F# J( A$ ]5 d4 j5 _7 E
176. }
     
177. 
     8 e/ N! b7 s; e# d6 y
178. /***************** 启动TIM8 *****************/
     
179. void TIM2_Startup(u32 frequency)   //启动定时器2
     
180. {
     . }8 j; X& J; r% ]5 P1 f7 F6 f
181.         u16 temp_arr=1000000/frequency-1;
     2 j) W0 x! M1 q5 a
182.         TIM_SetAutoreload(TIM2,temp_arr);//设定自动重装值        
     
183.         TIM_SetCompare2(TIM2,temp_arr>>1); //匹配值2等于重装值一半，是以占空比为50%，这个是一半高电平，一半低电平，
     
184.         //定时器计数到最高或最低就是产生一个脉冲，脉冲从这里发送到PA1（TIM2_CH2        ），占空比越大，输出的电压越大。
     8 m) ^; L" o( x) b2 Y
185.         TIM_SetCounter(TIM2,0);//计数器清零
     
186.         TIM_Cmd(TIM2, ENABLE);  //使能TIM2
     
187. }
     
188. void TIM3_Startup(u32 frequency)   
     
189. {
     5 `& P% J3 n# v1 [
190.         u16 temp_arr=1000000/frequency-1;
     $ A% @- g1 O$ o  Y
191.         TIM_SetAutoreload(TIM3,temp_arr);
     ; E3 k( A9 Z% T& S% D% s3 }$ }- G
192.         TIM_SetCompare2(TIM3,temp_arr>>1);
     
193.         TIM_SetCounter(TIM3,0);
     
194.         TIM_Cmd(TIM3, ENABLE);  
     ; u5 f- h( \% T2 y
195. }
     2 n* A* w: q0 u& ~( o
196. /********************************************
     ; Y+ x4 f* q1 ~- P' U8 I
197. //相对定位函数
     , D  `4 Z& b- M3 |& O2 m: a$ ], S
198. //num 0～2147483647
     
199. //frequency: 20Hz~100KHz
     " }( e8 j3 B4 Y  \& q" N& e
200. //dir: CW(顺时针方向)  CCW(逆时针方向)
     
201. *********************************************/
     . g5 g, H. i, H- b: B0 b, @
202. void Locate_Rle2(u32 frequency,DIR_Type dir) //相对定位函数
     
203. {
     , }3 q- j0 ~0 k+ z
204.         
     2 ^6 X' @' q. Q
205.         if(TIM2->CR1&0x01)//上一次脉冲还未发送完成  直接返回，TIM2->CR1=0x01是使能定时器，
     9 E) r* f7 y6 A  L; x. S$ b
206.                 //上面中断2函数进入后，产生一个脉冲，然后定时器自动关闭，再程序中开启，即TIM2->CR1=0x01
     
207.         {
     
208.                 printf("\r\nThe last time pulses is not send finished,wait please!\r\n");
     8 c1 `' K0 m: {# s/ P
209.                 return;
     
210.         }
     / @7 g& N7 r3 d+ e' y" t& v+ c- [8 Q7 B
211.         if((frequency<20)||(frequency>100000))//脉冲频率不在范围内 直接返回
     
212.         {
     ( I3 U! p3 B% X( D2 i9 P7 C% v
213.                 printf("\r\nThe frequency is out of range! please reset it!!(range:20Hz~100KHz)\r\n");
     
214.                 return;
     # R4 F$ F$ e" Z. U. \0 v
215.         }
     
216.         motor_dir2=dir;//将枚举类型为DIR_Type的dir的值赋值给另一个枚举类型motor_dir2，方便在中断中判断motor_dir2是否为正
     8 ^1 A0 }- P) `2 O- h
217.         //然后在中断中的current_pos[0]进行总和计算出当前的位置
     & q9 s; P0 F; j. n* K9 m& L
218.         DRIVER_DIR2=motor_dir2;                                 //将旋转方向赋值给DRIVER_DIR2所定义的接口
     
219.         TIM2_Startup(frequency);                                 //开启TIM2
     & M0 C1 l. t2 N7 X8 c2 J
220. }
     # x2 W4 C! ?/ K6 c! R
221. void Locate_Rle3(u32 frequency,DIR_Type dir) //相对定位函数
     3 {% w, j( y' n' w* _  L
222. {
     
223.         
     
224.         if(TIM3->CR1&0x01)
     
225.         {
     
226.                 printf("\r\nThe last time pulses is not send finished,wait please!\r\n");
     
227.                 return;
     # {% e: U" m( ^& X; A/ a: E
228.         }
     
229.         if((frequency<20)||(frequency>100000))
     & v: \4 e: E/ y) D
230.         {
     % Z! q/ t1 p6 Z( M. L3 B4 j% y6 w
231.                 printf("\r\nThe frequency is out of range! please reset it!!(range:20Hz~100KHz)\r\n");
     0 x8 x- @* m, Q% {( M* O
232.                 return;
     2 j/ Z& {  _3 a9 g% |$ ^
233.         }
     , _. C% N0 I9 N: h* E4 q, y
234.         motor_dir3=dir;
     , r. j3 a0 Y% Q, B9 i7 k* O
235.         DRIVER_DIR3=motor_dir3;
     
236.         TIM3_Startup(frequency);
     8 W4 {# t" t( z
237. }

复制代码

下面我简述一下这个程序的效果，就是通过按键1和按键2来操作步进电机，通过按下按键1后，两个步进电机同时向同一个方向旋转一圈，按下按键2后，两个步进电机同时向另一个方向旋转一圈。
————————————————
4 F( {* a4 A2 ^0 V( X* X8 ~) J( @版权声明：i土豆
' l5 Y  S1 t' v; d( z

& F% _! \1 `; \2 u/ I. G( @. j# b