一、关于步进电机那点事
9 t7 X& d5 A/ x) f1 C这次使用的是二相步进电机，博客上也有许多关于步进电机的博文啊，质量也是参差不齐，今天就给大家仔细的介绍一下该电机，我主要还是继承以往的风格，资料方面我也讲的少，主要还是侧重实操方向，希望能够带给大家帮助

2 q- D( J! p3 p: Z! j4 u5 \( w  m下面是图：
; f* n( M/ M$ a- ~/ {% Q* n, z


; `7 T1 {' s% V, T首先要认识一下步进电机上的几条线：

四条线（红、蓝、绿、黑）

3 q5 B8 g) _, e) X5 x+ e正常来说对应A+、A-、B+、B-，在电机上基本上也都会标明代表含义，其实步进电机的原理其实都差不多，主要就是学会使用和了解原理就基本上达到我们的目的了，如果想要深入学习，那可以再继续研究······

那么怎么使用呢？首先就要搭配一款步进电机的驱动器了，网上随便都可以买到，如图：

( g6 }7 x! i5 g# u( _; `
9 s# c9 T2 R1 Q5 `7 s) i, X2 B1 O
这里我们很明显可以看到它有12个接口，这里再详细介绍一下如何使用接口：
9 {9 }$ b5 T( P, O3 Y
5 v: S' v9 A' x( d7 W6 ZV+：连接电源正极（注意电压在9V~32V之间即可，过大的话你懂得）

GND:连接电源负极

$ o0 Z/ `2 L8 l) TA+：连接电机绕组A+相
5 D2 Y! y% w# B5 M7 H$ P$ u
5 C" O( Z! R) u6 eA- ： 连接电机绕组A-相

B+：连接电机绕组B+相
: U) q* h2 d# f0 w+ C& U
B- ： 连接电机绕组B-相
% W: t8 W8 ]5 H3 g1 B. }
4 J& N: o  X6 z: f1 C2 X% QCP+：脉冲信号输入正 ( PUL+ )（取决于共阴、共阳接法再来接线，共阴的话CP-接地，CP+接脉冲信号即定时器PWM输出）
, g9 }8 }/ @" v
CP-：脉冲信号输入负  ( PUL-)

  t( i; }: X, ~! r8 ]  R2 QDIR+：电机正、反转控制正（同样取决于共阴共阳接法）

) g3 z' {" c; R4 h; |% P& iDIR-：电机正、反转控制负

EN+：电机脱机控制正（可以不接）
/ q6 s- J/ z0 E3 A5 f. ]/ _+ O
EN-：电机脱机控制负

二、接线问题
: t( L; u: k! ~  S+ P8 y: r) V" p上面到这可能对它的接线有了一个想法了，那么具体如何接线呢？嘿嘿，这里有共阴和共阳的常见的两种接法，具体参照下图：
9 g9 |# M/ L1 h. B2 a; Z- r# M
" L, `; S6 _& G& d: ?& ~


/ ^8 I* @8 _& ~2 |1 \& L# n$ A
! Q2 r8 W7 l( [: B 这里我采用了共阴极的接法
, d# a/ l. a7 j
那么我的接线：

9 k# n# k0 h' x5 U5 k1 t) b7 L/ ~DIR+：PA8（随便一个端口即可）
8 Y1 A( z. i( H7 P: I  P# S
DIR-：GND
0 J6 [' P% l* l! {4 X" P  K5 Y" t
$ t$ Z5 C- \' J' V* }CP+：PA1(TIM2通道2)

CP-：GND
% E3 {9 B0 h* i( L" n
+ a8 D9 L/ q8 n+ `ENA不接
( w% h+ V$ n- x3 D" `. q
三、主要代码
5 O  w, p. j* y% X0 R& A9 R这里的代码搬运后修改一些的，即可上手即可用

主函数

3 c% ~8 S3 {( F5 v3 B) j4 Z) ^) g

1. #include "stm32f10x.h"
   
2. #include "sys.h"
   / i4 M& X" S6 j  o
3. #include "usart.h"
   ! M8 |! A* e2 l8 e8 T  n7 l6 n
4. #include "delay.h"
     Y3 o4 O. y& l' H8 \
5. #include "key.h"
   
6. #include "led.h"         
   3 k. W0 G! c- j" e5 n2 C8 r' Q& Y
7. #include "usmart.h"        
   $ q/ f+ @( l7 Q4 w
8. #include "driver.h"
   
9. 
   7 |: Q( Y- {) L3 J3 H6 t  e
10. //共阴
    
11. /*
    9 w; Z6 t1 q' G
12. CP+->PA.1   CP-接GND
    - {# X3 A2 N" i9 V/ J" \/ d
13. DIR+->PA.8  DIR-接GND
    # }5 Z3 u6 {* P0 \" k
14. */
    - A  ^% ]! \+ z. C
15. 
    * ~" b" \: \, p
16. int main(void)
    2 ^* U( r2 i6 j  T7 N4 X8 w
17. {         
    0 e7 |( Y; ^6 s1 K* ^0 a+ K  L5 z
18.         delay_init();                              
    ' N4 ?2 l" q' B7 w7 \  X$ G
19.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);         
    , a& p. H1 g0 Q
20.         uart_init(115200);            
    
21.         KEY_Init();                        
    # i' n$ \; K2 u+ G9 j5 ~" o/ [+ K
22.         Driver_Init();                        
    5 |. H4 N1 \8 ?! P0 _* K# q- Z
23.         TIM2_Init(999,72-1);      
    4 Q6 P4 g+ o7 e# g. }1 k1 i; t
24.         while(1)
    
25.         {        
    
26.                         Locate_Rle2(500,CW);
    
27.                         delay_ms(5000);
    
28.                         delay_ms(5000);
    
29.                         delay_ms(5000);
    % y1 T) I8 l, f9 _* g2 m+ R
30.                         Locate_Rle2(500,CCW);
    
31.                         delay_ms(5000);
    2 ~. f9 e( `, K3 O8 T
32.                         delay_ms(5000);
    , p: D) ]% _0 @0 L4 ?) j0 C
33.                         delay_ms(5000);
    
34.                 }
    3 Y3 e- F1 ~- H# n( r
35. 
    
36. }        

复制代码

定时器函数：

. O: [$ ^) z; |8 e$ B' R

1. #include "stm32f10x.h"
   
2. #include "driver.h"
   1 `! V4 O2 b- D2 Y! [: P4 s' V' z
3. #include "delay.h"
     u, ~( ]( j9 O$ Z3 Z4 H+ `
4. #include "usart.h"
   
5. 
   $ |: @' b6 P* q3 H: }) x
6. long current_pos[2]={0,0};
   9 w. m* w% }8 f, ~* l/ X: [
7. int motor_dir2=0;
   
8. u8 count[2]={0,0};
   
9. 
   3 P+ H: f3 Z8 C% o5 p
10. void Driver_Init(void)
    
11. {
    0 ~# E7 y% L- V
12.         GPIO_InitTypeDef  GPIO_InitStructure;
    
13. 
    5 r3 a9 `2 M$ D# k
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        
    
15. 
    
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;        
    
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 
    
18.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    ; h0 f3 A) s  T! n9 ?5 ]
19.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
    0 d3 u. D* n3 `( w- i9 o( v
20.         GPIO_SetBits(GPIOA,GPIO_Pin_8);                                                
    / [$ d# i. o# N& l  L
21. }
    / W: o* k8 P2 S* |& v
22. 
    
23. 
    
24. void TIM2_Init(u16 arr,u16 psc)
    
25. {                                                         
    
26.         GPIO_InitTypeDef GPIO_InitStructure;
    
27.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    7 O9 z* J" T/ ?, N& [$ D
28.         TIM_OCInitTypeDef  TIM_OCInitStructure;
    4 S3 J7 O1 N* e6 \' j. |
29.         NVIC_InitTypeDef NVIC_InitStructure;
    4 c2 m9 A3 z. T) S' a: a/ b4 a% y
30. 
    
31.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);         
    
32.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);                                                                              
    
33. 
    0 E' c! `3 A$ f+ h% ^$ O7 \" ~9 \2 _
34.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                                //TIM2_CH2
    0 y' j/ ~8 N& s5 h
35.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                        
    ; l* [) L& O4 g, t; O
36.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ! z- V6 y6 x) l" d9 f% w
37.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    4 G8 a; k) H2 k5 L8 f
38.         
    
39.         TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
    % l. l, _+ X0 C5 }+ F2 g
40.         
    - S. V; ^0 s: Y# ~
41.         TIM_TimeBaseStructure.TIM_Period = arr;                                         
    ! t1 {1 p+ d) H# m
42.         TIM_TimeBaseStructure.TIM_Prescaler =psc;                                
    
43.         TIM_TimeBaseStructure.TIM_ClockDivision = 0;                        
    8 v( S- p8 K0 r9 g" C0 G! @
44.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
45.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);                 
    
46.         TIM_ClearITPendingBit(TIM2,TIM_IT_Update);                                
    4 ^1 W: ^1 L9 u8 ~- o1 ^* u
47. 
    
48.         TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Regular);
    
49.         TIM_SelectOnePulseMode(TIM2,TIM_OPMode_Single);                        
    
50.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;               
    
51.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    1 x& O2 W+ m9 c
52.         TIM_OCInitStructure.TIM_Pulse = arr>>1;                                 
    
53.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    
54.         TIM_OC2Init(TIM2, &TIM_OCInitStructure);                                 
    
55. 
    
56.         TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);                  
    
57.         TIM_ARRPreloadConfig(TIM2, ENABLE);                                         
    
58.         
    ' ~* U; T$ a2 y& i' z
59.         TIM_ITConfig(TIM2, TIM_IT_Update ,ENABLE);                          
    9 s( p' D+ v: v
60. 
    0 Z4 i2 L: z9 h. w* ~, j& S. a
61.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                  
    
62.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
    
63.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                 
    + f  ], A- E5 H# w2 V" E- c; S
64.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         
    
65.         NVIC_Init(&NVIC_InitStructure);                                                  
    1 B5 l6 v! T/ c: V
66.         
    9 N/ }* i+ K6 h4 r# s
67.         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);                          
    
68.         TIM_Cmd(TIM2, DISABLE);                                                                                                                           
    2 y! i8 q" w0 Q* o3 A
69. }
    # |" x0 R8 U& C8 j
70. /******* TIM2*********/
    
71. void TIM2_IRQHandler(void)
    2 {) s0 H! \# ^# z& D% g& M; T
72. {
    " G6 X  V: _+ I4 M
73.         if(TIM_GetITStatus(TIM2,TIM_FLAG_Update)!=RESET)
    
74.         {
    9 n! G7 U+ X2 m" ]6 M; y
75.                 TIM_ClearITPendingBit(TIM2,TIM_FLAG_Update);        
    3 H8 `1 t+ r$ d1 q* S9 y0 U5 y
76.                 count[0]++;
    $ j( I# E/ N5 n
77.                 TIM_GenerateEvent(TIM2,TIM_EventSource_Update);
    ' l5 d8 z6 K1 A" x
78.         
    ! Z& W# R2 p* o
79.                 TIM_Cmd(TIM2, ENABLE);                                            
    
80. 
    
81.                 if(count[0]==200)
    
82.                 {
    
83.                         if(motor_dir2==CW)                                                   
    
84.                                 current_pos[0]+=count[0];
    6 W" K0 n9 Y4 P# C' M' |
85.                         else                                                                    
    , r( I8 z2 m  X! b, ]9 c) P3 s
86.                                 current_pos[0]-=count[0];
    
87.                         TIM_Cmd(TIM2, DISABLE);                                                   
    
88.                         printf("motor2µ±Ç°Î»ÖÃ=%ld\r\n",current_pos[0]);
    
89.                         count[0]=0;
      O! i! f) ^. u+ @* I1 o
90.                 }
    2 Z9 p0 p9 X! g4 A/ [
91.         
    $ e. P3 J% h, M* p: Y
92.         }
    
93. }
    # M" w% Y( O! Y; @8 s) d
94. 
    ' a, Y% `$ z2 y
95. void TIM2_Startup(u32 frequency)   
    
96. {
    ; W7 D1 o& ~1 s! `
97.         u16 temp_arr=1000000/frequency-1;
    
98.         TIM_SetAutoreload(TIM2,temp_arr);
    
99.         TIM_SetCompare2(TIM2,temp_arr>>1);
    
100.         
       ^( p6 q% ?& d# a# O0 q, P" ?, J
101.         TIM_SetCounter(TIM2,0);
     
102.         TIM_Cmd(TIM2, ENABLE);  
     
103. }
     
104. 
     # C* d/ [% d0 s- ?8 ~
105. 
     ' w( A3 I7 p# F; d& A& {7 w0 w6 p
106. void Locate_Rle2(u32 frequency,DIR_Type dir)
     " |5 `# j5 e$ \. Z9 ~& A! O0 _
107. {
     % K& S) `! p- E! G4 |5 w
108.         
     
109.         if(TIM2->CR1&0x01)
     6 B! b# N8 l8 O1 R
110.         {
     & r# Y: i7 k+ s' V$ e: b0 D
111.                 printf("\r\nThe last time pulses is not send finished,wait please!\r\n");
     $ H3 Q- M3 C& m( Z
112.                 return;
     
113.         }
     
114.         if((frequency<20)||(frequency>100000))
     . a3 X, v, H* {: w+ S( ~
115.         {
     
116.                 printf("\r\nThe frequency is out of range! please reset it!!(range:20Hz~100KHz)\r\n");
     
117.                 return;
     
118.         }
     7 J/ E  J% G+ [" V# p9 ~% t
119.         motor_dir2=dir;
     
120.         
     
121.         DRIVER_DIR2=motor_dir2;                                
     8 u+ e' I$ B% T! U5 V% W7 A; e2 s
122.         TIM2_Startup(frequency);                        
     ; T$ n- c7 q0 R6 w
123. }
     

复制代码

到这里你就会发现其实原理还是相当简单的，剩下的也不再深入了，希望能够对大家帮助哈哈
5 q/ e( n- y: H, ^
; R& {. ]( v" u0 f5 `实现目的：

: G1 x8 M, y2 p. y& ?该程序就是实现正转后隔一会再反转，大家可以根据自己需求设置到自己想要的转动情况，同时要让他停下来，只需要在自己需要的地方设置一个TIM_SetCompare2（TIM2,0）即可停下，可以自由设置。
8 f9 Z: @' i8 ]/ P9 Z( R
3 `; C0 ^- i3 N. p4 F; m, P四、总结
今天关于步进电机就暂且介绍到这里，后面有需要会再特别介绍一下，文章写得还是比较简单，相信对于你还是可以很轻松入手的
2 h& U3 u3 P0 [6 E% u3 m) I
1 `4 b# [2 g/ w+ N' F9 n) ?/ o- y
7 U% v$ @# M% u* m/ z: T