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

下面是图：
; O5 A/ s* M. t$ r$ L1 }4 e

% A& S, \, \& N  [# ~- C
, }- {9 i2 I$ e: t; ^9 v' r$ [1 J首先要认识一下步进电机上的几条线：
, D, p( O( a! g4 ^. b1 B/ P. ?! c& C
四条线（红、蓝、绿、黑）

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

那么怎么使用呢？首先就要搭配一款步进电机的驱动器了，网上随便都可以买到，如图：
3 b  Q5 C- E7 [. [
! w3 ~& ~" }) Y
, Y1 x- U) ]4 f9 J6 A
这里我们很明显可以看到它有12个接口，这里再详细介绍一下如何使用接口：
$ k% R7 ^1 S2 w* p6 z) ~1 D
0 A# f9 e; N( A3 w' u7 G1 ^V+：连接电源正极（注意电压在9V~32V之间即可，过大的话你懂得）
4 e/ H$ F; u; n; K4 T9 Z: X" I
: x9 M; i/ O  ^( V4 CGND:连接电源负极

A+：连接电机绕组A+相
3 L+ }, h( k2 n& s1 m" c0 v
; O; `3 Q+ R0 I' p/ fA- ： 连接电机绕组A-相
. p6 i+ \$ `& R9 m' b( U# Z. j
) i, h: f5 v0 ?6 E" mB+：连接电机绕组B+相

B- ： 连接电机绕组B-相
9 t8 z; i6 Y* w
; c( i( L( Q+ C8 V% x5 @, |CP+：脉冲信号输入正 ( PUL+ )（取决于共阴、共阳接法再来接线，共阴的话CP-接地，CP+接脉冲信号即定时器PWM输出）
, W: b/ q8 W, b2 w
$ |* ]' h/ P4 j, b' h% V/ jCP-：脉冲信号输入负  ( PUL-)

DIR+：电机正、反转控制正（同样取决于共阴共阳接法）

DIR-：电机正、反转控制负

; Q  {' B# o" `EN+：电机脱机控制正（可以不接）
$ A% N, B( r* t  M# a, d" n) @
EN-：电机脱机控制负
) l; S+ R9 e6 w; \( h- a0 A9 G+ u
二、接线问题
  t- {0 X! F4 v, i$ {上面到这可能对它的接线有了一个想法了，那么具体如何接线呢？嘿嘿，这里有共阴和共阳的常见的两种接法，具体参照下图：
2 _# |* E4 [& U0 }


- z( P4 W7 h9 N" E/ P! ]: }
. S( y" z6 |6 E, d# V
这里我采用了共阴极的接法
$ C) d6 K4 W( k+ F2 v1 c
3 Z$ e# k! L- s那么我的接线：

9 Q; H2 Q+ g7 Y; wDIR+：PA8（随便一个端口即可）

DIR-：GND
9 M2 M- A* `, }, g8 J4 `% K
) v: B0 a( u- V3 g6 U. C: bCP+：PA1(TIM2通道2)

  k) l; Y& P% _* Y: r& a4 bCP-：GND

; W; d/ r4 y0 r! G" jENA不接

8 ^: i% W( h8 S% W三、主要代码
5 p. R  @- \+ F: a6 b这里的代码搬运后修改一些的，即可上手即可用

7 \8 m* g& [( k3 c主函数

1. #include "stm32f10x.h"
   
2. #include "sys.h"
   
3. #include "usart.h"
   
4. #include "delay.h"
   9 G2 V) `( ?$ s; G9 V1 j
5. #include "key.h"
   2 [: g3 G* F% g. F8 B
6. #include "led.h"         
   : h- v" s0 D; u- q# ~
7. #include "usmart.h"        
   ( I3 u# ?( F( {# Q6 ]. e) f$ `/ h
8. #include "driver.h"
   
9. 
   + I0 D1 Q1 v4 n0 O5 {# `
10. //共阴
    ; J0 S% m. `) N$ G! t* \4 s# I
11. /*
    
12. CP+->PA.1   CP-接GND
    ) q# x) C1 M! d2 g  [
13. DIR+->PA.8  DIR-接GND
    
14. */
    6 i  b: }# A0 ~/ o% d
15. 
    
16. int main(void)
    " x5 D7 ?. ~$ \8 Y. F3 \/ ?
17. {         
    
18.         delay_init();                              
    : U* F# d& p& Q0 H) L8 s4 X
19.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);         
    
20.         uart_init(115200);            
    / x' v$ I8 n) {
21.         KEY_Init();                        
    ) n( @) S4 C% \) Z5 \( f: s) E
22.         Driver_Init();                        
    ; a1 t0 g( K  |1 K) D7 ?( F2 M
23.         TIM2_Init(999,72-1);      
    5 z& s- `9 T% N: K  j, F9 {
24.         while(1)
    & l* Y% B8 X+ v# a
25.         {        
    - Z' l$ O+ {6 k4 O
26.                         Locate_Rle2(500,CW);
    8 B( j5 l9 M6 G
27.                         delay_ms(5000);
    ! N/ o& g9 ?2 Q0 U
28.                         delay_ms(5000);
    ) `  y( X, ?: h; K
29.                         delay_ms(5000);
    
30.                         Locate_Rle2(500,CCW);
    " z9 h6 `6 M$ o
31.                         delay_ms(5000);
    
32.                         delay_ms(5000);
    
33.                         delay_ms(5000);
    " ~3 O0 R) H3 |& B* ]! y# ^
34.                 }
    
35. 
    + M2 K. k% G4 ]; m$ Z  A$ a
36. }        

复制代码

' `: b9 F: j+ `  _$ g7 m 定时器函数：

1. #include "stm32f10x.h"
   : H- a2 a4 [4 S4 b
2. #include "driver.h"
   * \, F! S, V' Q$ q# |% I% ^" `
3. #include "delay.h"
   
4. #include "usart.h"
   
5. 
   
6. long current_pos[2]={0,0};
   / J6 V( }* |1 l8 q+ k; p2 L$ h
7. int motor_dir2=0;
   2 \, J: Z* q6 @( n% y# J
8. u8 count[2]={0,0};
   
9. 
   % x% n1 F$ N: B9 ?: B  x" x
10. void Driver_Init(void)
      r) t- h; V6 x# f& }. g
11. {
    6 r0 f+ N9 T# W) Y+ b
12.         GPIO_InitTypeDef  GPIO_InitStructure;
    
13. 
    
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        
    , L8 A6 Y/ }$ p8 Q6 J; E1 h3 `
15. 
    3 k4 F0 }  m/ K8 i& {4 C* C! |5 A% ?9 [
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;        
    ( o2 `# K) D8 t% S
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 
    . m: e: j9 j1 C1 O' x; X* C7 A
18.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    * T( Q( M3 S, _! o" Q/ b
19.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
    * G" X$ N$ G  b; M# Q
20.         GPIO_SetBits(GPIOA,GPIO_Pin_8);                                                
    
21. }
    
22. 
    
23. 
    
24. void TIM2_Init(u16 arr,u16 psc)
    5 g( J* k6 O- Z* W3 ?9 n: {
25. {                                                         
    
26.         GPIO_InitTypeDef GPIO_InitStructure;
    ! C- C9 `7 _/ Q2 i8 z  L
27.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    & E: I9 a# R8 B# i& E# Y) e" f- L
28.         TIM_OCInitTypeDef  TIM_OCInitStructure;
    
29.         NVIC_InitTypeDef NVIC_InitStructure;
    
30. 
    
31.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);         
    
32.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);                                                                              
    
33. 
    " Q; p. F$ L' g0 I/ b  q
34.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                                //TIM2_CH2
    4 A' w# V( N9 v% v
35.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                        
    
36.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
37.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    ' `* i6 p. W! l1 p$ c$ f
38.         
    
39.         TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
    5 b  J% t0 p- ]" z
40.         
    7 h9 ]' M1 L/ S2 F" R2 m, [
41.         TIM_TimeBaseStructure.TIM_Period = arr;                                         
    - r8 Y# _+ D+ Z- [, L1 n5 B
42.         TIM_TimeBaseStructure.TIM_Prescaler =psc;                                
      `; |; z: X. Z5 e
43.         TIM_TimeBaseStructure.TIM_ClockDivision = 0;                        
    
44.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
45.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);                 
    
46.         TIM_ClearITPendingBit(TIM2,TIM_IT_Update);                                
    
47. 
    # Z* Z0 s4 S4 g# V
48.         TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Regular);
    8 K9 F' ?4 p" e. d5 m
49.         TIM_SelectOnePulseMode(TIM2,TIM_OPMode_Single);                        
    1 O# H) N1 M2 k0 x' @3 |% s
50.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;               
    . Z# e6 @# Z# w3 a* e6 r' T7 D
51.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    
52.         TIM_OCInitStructure.TIM_Pulse = arr>>1;                                 
    # \$ k: |) A' i5 I, ?2 v- Y  @
53.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    5 \$ {% l4 a0 h/ X4 G, p# N" m
54.         TIM_OC2Init(TIM2, &TIM_OCInitStructure);                                 
    
55. 
    % J/ e" I! _( Z3 {
56.         TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);                  
    
57.         TIM_ARRPreloadConfig(TIM2, ENABLE);                                         
    
58.         
    
59.         TIM_ITConfig(TIM2, TIM_IT_Update ,ENABLE);                          
    
60. 
    
61.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                  
    
62.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
    
63.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                 
    
64.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         
    
65.         NVIC_Init(&NVIC_InitStructure);                                                  
    - W5 H: ^& O. p- s7 |
66.         
    
67.         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);                          
    
68.         TIM_Cmd(TIM2, DISABLE);                                                                                                                           
    4 l9 j$ g. C5 x6 `6 [) x+ J
69. }
    / ]' F3 j+ h3 p0 A% E4 {: C
70. /******* TIM2*********/
    
71. void TIM2_IRQHandler(void)
    7 W. R5 y" n. f/ _) `. I
72. {
    6 ?# I3 [$ C# h+ ]* ^
73.         if(TIM_GetITStatus(TIM2,TIM_FLAG_Update)!=RESET)
    
74.         {
    % q# N: F! U& W- [  W
75.                 TIM_ClearITPendingBit(TIM2,TIM_FLAG_Update);        
    
76.                 count[0]++;
    
77.                 TIM_GenerateEvent(TIM2,TIM_EventSource_Update);
    8 x5 a! A" t2 g# K
78.         
    
79.                 TIM_Cmd(TIM2, ENABLE);                                            
    
80. 
    
81.                 if(count[0]==200)
    - t6 h4 M* [8 i  C7 P. ?
82.                 {
    
83.                         if(motor_dir2==CW)                                                   
    
84.                                 current_pos[0]+=count[0];
    ) g# _' L9 N. _7 F3 C
85.                         else                                                                    
    * r6 ~( I1 }) |, a
86.                                 current_pos[0]-=count[0];
    / f2 v* _2 {; [- O: }
87.                         TIM_Cmd(TIM2, DISABLE);                                                   
    ; G* q% M) r7 _! E$ C, s' u& [1 P+ i
88.                         printf("motor2µ±Ç°Î»ÖÃ=%ld\r\n",current_pos[0]);
    
89.                         count[0]=0;
    
90.                 }
    
91.         
    
92.         }
    
93. }
    
94. 
    
95. void TIM2_Startup(u32 frequency)   
    5 x3 k, }! d/ A& @9 K3 |+ p
96. {
    ) ~4 u& @9 x  g
97.         u16 temp_arr=1000000/frequency-1;
    / P+ X" \7 N9 v& H% ^! w
98.         TIM_SetAutoreload(TIM2,temp_arr);
    + B: ]$ v4 G! P5 \7 I+ J; R2 H4 s
99.         TIM_SetCompare2(TIM2,temp_arr>>1);
    
100.         
     & Y$ e4 v$ F$ Y5 f) P" e1 z% G, ?
101.         TIM_SetCounter(TIM2,0);
     9 E) D* Z5 Q( `9 o" C
102.         TIM_Cmd(TIM2, ENABLE);  
     4 l! ^# h5 t3 P0 c) r9 S2 z
103. }
     
104. 
     * t% B+ ]" R0 p/ Q: Y
105. 
     
106. void Locate_Rle2(u32 frequency,DIR_Type dir)
     
107. {
     - Y0 J9 z5 T, o  W5 S4 X
108.         
     ( `, C: v/ Z# |( z; T
109.         if(TIM2->CR1&0x01)
     3 d" ]; Y( R1 B- X4 R
110.         {
     + }" ^" U8 T# |- A6 e. ~
111.                 printf("\r\nThe last time pulses is not send finished,wait please!\r\n");
     
112.                 return;
     4 s4 M3 W, g6 [
113.         }
     ; d) Z$ N4 q: a' ~) [3 l
114.         if((frequency<20)||(frequency>100000))
     
115.         {
     8 h& z/ \; e3 U/ p
116.                 printf("\r\nThe frequency is out of range! please reset it!!(range:20Hz~100KHz)\r\n");
     
117.                 return;
     
118.         }
     
119.         motor_dir2=dir;
     
120.         
     
121.         DRIVER_DIR2=motor_dir2;                                
     ! m* [7 S7 a; ^8 H! s
122.         TIM2_Startup(frequency);                        
     ; M. O0 I+ S5 o) o; q) Z3 T: G2 _
123. }
     

复制代码

到这里你就会发现其实原理还是相当简单的，剩下的也不再深入了，希望能够对大家帮助哈哈
+ b: h, R* N$ V) r0 o) p2 F
实现目的：

该程序就是实现正转后隔一会再反转，大家可以根据自己需求设置到自己想要的转动情况，同时要让他停下来，只需要在自己需要的地方设置一个TIM_SetCompare2（TIM2,0）即可停下，可以自由设置。
, \8 Q% \5 x0 y; I
6 Z' ~9 F' c9 [7 Z, r( R. C四、总结
今天关于步进电机就暂且介绍到这里，后面有需要会再特别介绍一下，文章写得还是比较简单，相信对于你还是可以很轻松入手的


) y% E( k4 u$ y$ b* V