一、关于步进电机那点事
这次使用的是二相步进电机，博客上也有许多关于步进电机的博文啊，质量也是参差不齐，今天就给大家仔细的介绍一下该电机，我主要还是继承以往的风格，资料方面我也讲的少，主要还是侧重实操方向，希望能够带给大家帮助
) V2 @/ @6 \( M, G/ J
# J+ E# y: O3 i4 @" d5 i下面是图：



首先要认识一下步进电机上的几条线：
/ F; _$ ^' N* z# s! p
- C; O! F, c! E* u6 l1 t" N1 c* ^  W四条线（红、蓝、绿、黑）

4 Y1 B9 O* g! ?8 F正常来说对应A+、A-、B+、B-，在电机上基本上也都会标明代表含义，其实步进电机的原理其实都差不多，主要就是学会使用和了解原理就基本上达到我们的目的了，如果想要深入学习，那可以再继续研究······

那么怎么使用呢？首先就要搭配一款步进电机的驱动器了，网上随便都可以买到，如图：
! G$ H6 }# s- o: T
- c0 s, \% ?4 C
) q0 s! l/ f; `
这里我们很明显可以看到它有12个接口，这里再详细介绍一下如何使用接口：

V+：连接电源正极（注意电压在9V~32V之间即可，过大的话你懂得）

GND:连接电源负极
( b9 K5 r' g- Q
+ q# j) u% M, }. Q8 x) V( ?* I4 k" mA+：连接电机绕组A+相

$ Y+ K+ F" P+ h; p- A2 sA- ： 连接电机绕组A-相
' d; K  ?/ ~$ y
B+：连接电机绕组B+相

B- ： 连接电机绕组B-相
& k5 o$ z3 x. A; M# x
CP+：脉冲信号输入正 ( PUL+ )（取决于共阴、共阳接法再来接线，共阴的话CP-接地，CP+接脉冲信号即定时器PWM输出）

CP-：脉冲信号输入负  ( PUL-)
/ t+ q. U+ i* n  j% y
- ~" w1 @! ~; y! Y1 |& G" V* vDIR+：电机正、反转控制正（同样取决于共阴共阳接法）
5 h& f3 V- w0 ]
% u  `, ^% u2 G$ y+ q6 x" ADIR-：电机正、反转控制负

EN+：电机脱机控制正（可以不接）
0 B2 Q+ k8 c* N  L
EN-：电机脱机控制负
1 f2 U  q6 O0 K
二、接线问题
上面到这可能对它的接线有了一个想法了，那么具体如何接线呢？嘿嘿，这里有共阴和共阳的常见的两种接法，具体参照下图：
4 n, ?( j- ~6 n) s: I. B


. ]5 q) u% i, R) h, i& X1 S
! F- v4 s2 n5 [0 Z
& ?4 Z* O% N$ h- E8 k  d 这里我采用了共阴极的接法

$ l$ D% b8 t$ P/ c那么我的接线：
" J: }" q+ L& y5 i
DIR+：PA8（随便一个端口即可）

1 d# }5 @, q5 K5 r8 D' `  @DIR-：GND
9 g8 ?4 Y& o" h/ r; t6 q( d( L
CP+：PA1(TIM2通道2)
  l5 [$ h; u& W9 e& x- p& u# q. j  S
5 u1 K' K1 h  r. B$ K  c% I# }CP-：GND
6 f' f0 j/ G# N6 b* ~
ENA不接
5 a- F. n8 p: a, r9 |+ k8 d
三、主要代码
8 b, r0 {* Y& G- p  s4 H这里的代码搬运后修改一些的，即可上手即可用
5 {  |, R' C$ R* {* p- w# O5 Q7 v
! D- t% J' q4 ?) n1 o1 f主函数
+ L' L  Q% \; ^- R- U3 `9 R( _

1. #include "stm32f10x.h"
   ! @% M- X  C. H! x
2. #include "sys.h"
   
3. #include "usart.h"
   
4. #include "delay.h"
   
5. #include "key.h"
   
6. #include "led.h"         
   
7. #include "usmart.h"        
   * l# |  n; B3 l; {* P1 i: s
8. #include "driver.h"
   
9. 
   
10. //共阴
    
11. /*
    , a- {/ R& V3 o$ {7 E
12. CP+->PA.1   CP-接GND
    1 ]3 {9 P) O6 S) L) p5 B3 d' H
13. DIR+->PA.8  DIR-接GND
    * B2 ^! H. H$ }. R6 D2 n. t( [
14. */
    
15. 
    8 v. b; J9 h/ U
16. int main(void)
    
17. {         
    
18.         delay_init();                              
    
19.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);         
    5 w* i& w1 T' J6 J
20.         uart_init(115200);            
    
21.         KEY_Init();                        
    5 K/ ?; s0 }# b, y1 V$ x
22.         Driver_Init();                        
    
23.         TIM2_Init(999,72-1);      
    
24.         while(1)
    0 X/ n1 }# ?/ D& v" a+ E
25.         {        
    
26.                         Locate_Rle2(500,CW);
    
27.                         delay_ms(5000);
    % G. d$ m7 d3 [+ ~" X4 z
28.                         delay_ms(5000);
    : ]* {. Y- f% `# J5 X5 L
29.                         delay_ms(5000);
    " H) I& g" U! z: n. r
30.                         Locate_Rle2(500,CCW);
    + p& C8 q9 y; S- G
31.                         delay_ms(5000);
    8 b: [5 c# m' Z! i, o8 X
32.                         delay_ms(5000);
      [' `! T- U: G- |% |. Y
33.                         delay_ms(5000);
    * {9 ^9 _# J4 {$ I& a% \! X! [) r- _
34.                 }
    
35. 
    . ]/ o' M9 N9 i; L2 v0 z
36. }        

复制代码

定时器函数：
5 E4 c) u6 y, t( q
! X+ m1 M! l' T1 V2 \

1. #include "stm32f10x.h"
   
2. #include "driver.h"
   
3. #include "delay.h"
   9 D( l4 m' U& c- }' Z
4. #include "usart.h"
   
5. 
   ' \/ _1 u8 @  ~9 `% ]
6. long current_pos[2]={0,0};
     [0 _. Q5 f0 L# L) I- z+ N8 y; k
7. int motor_dir2=0;
   
8. u8 count[2]={0,0};
   : t+ j5 I/ f. I9 u+ {' O7 Z$ S
9. 
   4 K% }2 M* E) D& [& F
10. void Driver_Init(void)
    
11. {
    
12.         GPIO_InitTypeDef  GPIO_InitStructure;
    . z0 ^; r; Q! e2 Y
13. 
    
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        
    
15. 
    ; i) ]! V- Y' e/ l0 Q
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;        
    ) C/ p0 U4 O7 |
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 
    0 Y+ _! }4 O. [3 `6 S4 w
18.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    ; ^8 C" R- v0 J1 p5 v
19.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
    ) H  t6 @! g3 C
20.         GPIO_SetBits(GPIOA,GPIO_Pin_8);                                                
    
21. }
    
22. 
    ! e/ K) M" x9 V) e8 h
23. 
    6 R' W& L( F( O5 g
24. void TIM2_Init(u16 arr,u16 psc)
    
25. {                                                         
    
26.         GPIO_InitTypeDef GPIO_InitStructure;
    
27.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    0 X2 K( h* A) ~4 J
28.         TIM_OCInitTypeDef  TIM_OCInitStructure;
    
29.         NVIC_InitTypeDef NVIC_InitStructure;
    
30. 
    
31.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);         
    " o: a1 J" N7 D1 K4 @6 P+ E0 T5 H
32.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);                                                                              
    
33. 
    
34.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                                //TIM2_CH2
    
35.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                        
    9 Q; Q7 I7 r+ c, Q+ \  `. G, T# C
36.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
37.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
38.         
    5 g* m% E) g$ p3 i  _& a, |
39.         TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
    8 m: s# b% `& U* X7 N
40.         
    
41.         TIM_TimeBaseStructure.TIM_Period = arr;                                         
    
42.         TIM_TimeBaseStructure.TIM_Prescaler =psc;                                
    4 Z2 Q. o, N9 l* J; @2 f0 D8 g
43.         TIM_TimeBaseStructure.TIM_ClockDivision = 0;                        
    
44.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
45.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);                 
    . J' Y, b/ L& n; ~
46.         TIM_ClearITPendingBit(TIM2,TIM_IT_Update);                                
    
47. 
    " c5 A0 m+ a6 T! }# B$ m$ F$ r
48.         TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Regular);
    7 t+ H+ ~; L4 S0 I6 k% v7 Q; W0 r
49.         TIM_SelectOnePulseMode(TIM2,TIM_OPMode_Single);                        
    6 j: u" F' V2 U( m6 C8 Q
50.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;               
    ! j# C* ]$ o4 i$ R; F
51.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    
52.         TIM_OCInitStructure.TIM_Pulse = arr>>1;                                 
    8 ~: A0 g, Y6 f, t! P( @
53.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    
54.         TIM_OC2Init(TIM2, &TIM_OCInitStructure);                                 
    
55. 
    9 C9 R+ i8 F" V  n6 z
56.         TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);                  
    / N0 b) T! c7 z/ N" {7 d$ E7 o
57.         TIM_ARRPreloadConfig(TIM2, ENABLE);                                         
    . A, v; ]6 z; a0 K9 p4 j! U
58.         
    
59.         TIM_ITConfig(TIM2, TIM_IT_Update ,ENABLE);                          
    : h4 G# j: |  \6 u: |" G
60. 
    , ~8 M- h5 A: ], x
61.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                  
    
62.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
    / I" g; m& f5 V. f& l! w% v
63.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                 
    3 h3 v4 b7 @" g2 f" n( S
64.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         
    
65.         NVIC_Init(&NVIC_InitStructure);                                                  
    5 e2 N, O  o$ }6 S
66.         
    
67.         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);                          
    
68.         TIM_Cmd(TIM2, DISABLE);                                                                                                                           
    : O2 k+ o: a9 u: }/ m/ W- n, V. W
69. }
    1 W  N8 B# z  g
70. /******* TIM2*********/
    
71. void TIM2_IRQHandler(void)
    
72. {
    
73.         if(TIM_GetITStatus(TIM2,TIM_FLAG_Update)!=RESET)
    
74.         {
    - Z9 F; _$ L* G
75.                 TIM_ClearITPendingBit(TIM2,TIM_FLAG_Update);        
    
76.                 count[0]++;
    
77.                 TIM_GenerateEvent(TIM2,TIM_EventSource_Update);
    ' U% O! a6 @: P0 }' E
78.         
    
79.                 TIM_Cmd(TIM2, ENABLE);                                            
    
80. 
    
81.                 if(count[0]==200)
    
82.                 {
    
83.                         if(motor_dir2==CW)                                                   
    
84.                                 current_pos[0]+=count[0];
    
85.                         else                                                                    
    
86.                                 current_pos[0]-=count[0];
      `$ K& |+ x' U* g; P. _* U
87.                         TIM_Cmd(TIM2, DISABLE);                                                   
    
88.                         printf("motor2µ±Ç°Î»ÖÃ=%ld\r\n",current_pos[0]);
    
89.                         count[0]=0;
    
90.                 }
    
91.         
    
92.         }
    
93. }
    
94. 
    
95. void TIM2_Startup(u32 frequency)   
    
96. {
    
97.         u16 temp_arr=1000000/frequency-1;
    , V  }8 B" |; b& _% C$ D
98.         TIM_SetAutoreload(TIM2,temp_arr);
    # c2 K' A5 g; d3 O+ r3 y, ?- {7 H5 U
99.         TIM_SetCompare2(TIM2,temp_arr>>1);
    
100.         
     % W! e2 {. Q& X/ _
101.         TIM_SetCounter(TIM2,0);
     
102.         TIM_Cmd(TIM2, ENABLE);  
     * V: X$ `1 M" ^. `8 S5 i
103. }
     
104. 
     , t/ R. m) b' H+ k. ~# r& h2 A
105. 
     2 [1 Y" r3 f# }
106. void Locate_Rle2(u32 frequency,DIR_Type dir)
     
107. {
     
108.         
     - ]5 O4 G) I% O/ R' j
109.         if(TIM2->CR1&0x01)
     
110.         {
     ; ?/ L& H9 n/ ]! F7 V
111.                 printf("\r\nThe last time pulses is not send finished,wait please!\r\n");
     6 }) l/ Z4 y3 s/ `5 \/ d  A
112.                 return;
     
113.         }
     
114.         if((frequency<20)||(frequency>100000))
     
115.         {
     
116.                 printf("\r\nThe frequency is out of range! please reset it!!(range:20Hz~100KHz)\r\n");
     $ L' S+ h9 f9 Q; E$ {, A' H* H
117.                 return;
     
118.         }
     
119.         motor_dir2=dir;
     
120.         
     
121.         DRIVER_DIR2=motor_dir2;                                
     / p( A& D4 e4 u5 z" t* E
122.         TIM2_Startup(frequency);                        
     
123. }
     / c8 r0 A: O# m

复制代码

到这里你就会发现其实原理还是相当简单的，剩下的也不再深入了，希望能够对大家帮助哈哈

) i) k, T! Y1 g. c6 E实现目的：
4 F5 q- U$ m( O3 B9 x& o% I
+ c3 g# ~, g% i2 S5 e8 z0 l5 y该程序就是实现正转后隔一会再反转，大家可以根据自己需求设置到自己想要的转动情况，同时要让他停下来，只需要在自己需要的地方设置一个TIM_SetCompare2（TIM2,0）即可停下，可以自由设置。

4 J+ s/ v+ h$ Q4 Y四、总结
今天关于步进电机就暂且介绍到这里，后面有需要会再特别介绍一下，文章写得还是比较简单，相信对于你还是可以很轻松入手的


: ]* {2 q; J7 i