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

9 D! O& d2 Y8 g2 K下面是图：



首先要认识一下步进电机上的几条线：

% ?  ~7 P$ w+ ^/ }四条线（红、蓝、绿、黑）

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

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

7 Q% f* m7 T# {1 w% N9 l6 `8 X

这里我们很明显可以看到它有12个接口，这里再详细介绍一下如何使用接口：
4 R/ c+ v, |6 [2 R6 X
. A- k$ W0 W1 D6 G8 O/ ?+ u* fV+：连接电源正极（注意电压在9V~32V之间即可，过大的话你懂得）

GND:连接电源负极
" S# s' u2 j( F) [
5 f) B) ?& z1 e+ L7 I- WA+：连接电机绕组A+相

  g9 O1 }/ ]) vA- ： 连接电机绕组A-相

5 Y, Z% _# m9 G, U, PB+：连接电机绕组B+相

B- ： 连接电机绕组B-相

* i2 y% q( ~% e6 g2 Z0 e+ r! eCP+：脉冲信号输入正 ( PUL+ )（取决于共阴、共阳接法再来接线，共阴的话CP-接地，CP+接脉冲信号即定时器PWM输出）

CP-：脉冲信号输入负  ( PUL-)
+ J; ]2 m" `- e7 t8 i
DIR+：电机正、反转控制正（同样取决于共阴共阳接法）

) R0 c0 u6 O5 W, a# n8 U$ LDIR-：电机正、反转控制负

% |- D& s; Z# i, E4 L6 l- eEN+：电机脱机控制正（可以不接）
- ]4 T" n) }8 O' @
EN-：电机脱机控制负

- q$ e7 l$ G! b( j, ~: N" |' x; k二、接线问题
上面到这可能对它的接线有了一个想法了，那么具体如何接线呢？嘿嘿，这里有共阴和共阳的常见的两种接法，具体参照下图：

3 [4 \7 P3 _3 c$ J4 r) ?+ S- S



4 J6 Z: \3 A  V  V 这里我采用了共阴极的接法

7 Y* d$ J5 i8 q6 @那么我的接线：
  u0 t5 ~0 ]1 h, S' |' w7 g
DIR+：PA8（随便一个端口即可）
9 l# Y! |9 u) L  d: K; W
" W; f! U* M/ s# ?+ c1 f; jDIR-：GND

CP+：PA1(TIM2通道2)
9 M# {) ?1 V# V( j" r9 R. @
CP-：GND
/ V) S# a1 x5 x0 g, Z; n+ A# o
ENA不接

三、主要代码
这里的代码搬运后修改一些的，即可上手即可用
% V3 O2 V4 t6 u6 e8 c" ?6 a
主函数
) u  t" l# N' \( q

1. #include "stm32f10x.h"
   0 ~% @6 R" k" a' q+ a( k3 ?( ?5 `0 o
2. #include "sys.h"
   
3. #include "usart.h"
   , ~+ q. ^, l0 d6 W9 e# v' B
4. #include "delay.h"
   
5. #include "key.h"
   2 g% m4 b; J* W4 i9 m
6. #include "led.h"         
   
7. #include "usmart.h"        
     d+ P# ~' c; H& U+ a) T# t. T
8. #include "driver.h"
   
9. 
   + n8 h9 H7 ^$ t! t; J* l% L
10. //共阴
    9 L( u: B. m6 O6 |9 X3 E
11. /*
    
12. CP+->PA.1   CP-接GND
    7 o& I* C0 _8 W5 @9 G7 S
13. DIR+->PA.8  DIR-接GND
    ) v9 h) Z' j; _, G, |0 y& F
14. */
    
15. 
    . Q* r. s( `, H1 p
16. int main(void)
    * W  ^; r5 D7 \3 ^# u. y
17. {         
    . j2 d. |  j& i* Z3 I
18.         delay_init();                              
    ' E! x4 ^4 g! ?4 @
19.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);         
    
20.         uart_init(115200);            
    : W4 M  Z% k# \$ e) Q
21.         KEY_Init();                        
    - G/ h6 ]- w( C4 K" K
22.         Driver_Init();                        
    : E' B7 W5 q! A( D- B( S6 ~: ~' v
23.         TIM2_Init(999,72-1);      
    $ G7 c! C( D+ k% D7 k6 n  O: N
24.         while(1)
    
25.         {        
    - m2 d+ a; S/ |2 s
26.                         Locate_Rle2(500,CW);
    3 I% f( P' ?2 D+ W* ?' b
27.                         delay_ms(5000);
    * `% Q! }1 T! ]+ C, C' l
28.                         delay_ms(5000);
    
29.                         delay_ms(5000);
    
30.                         Locate_Rle2(500,CCW);
    
31.                         delay_ms(5000);
    7 ]5 g* N& K4 u+ w% k
32.                         delay_ms(5000);
    
33.                         delay_ms(5000);
    
34.                 }
    
35. 
    
36. }        

复制代码

定时器函数：
/ j6 t! j9 G5 `- u$ m" a5 s
: p- ]8 |3 J/ k1 D4 \; T

1. #include "stm32f10x.h"
   
2. #include "driver.h"
   $ E6 B( Y( l& j7 [, l0 l
3. #include "delay.h"
   & b% U0 h1 P3 g6 v5 p
4. #include "usart.h"
   
5. 
   ( Q: R/ _9 ^$ c$ s0 G0 ?3 Z! o
6. long current_pos[2]={0,0};
   2 D) q+ y$ ]9 }2 S  W! @
7. int motor_dir2=0;
   
8. u8 count[2]={0,0};
   3 _/ j4 s1 m5 ?5 B$ `2 B0 W2 Q: i
9. 
   ' ?: ^! {) ~$ z! z
10. void Driver_Init(void)
    
11. {
    
12.         GPIO_InitTypeDef  GPIO_InitStructure;
    . u( K( r- \4 H3 }) w6 u8 k, s( U+ y
13. 
    $ v4 _# m+ |+ f9 P- O" d7 z
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        
    + B8 s' U; f* ~2 Y3 q- c
15. 
    
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;        
    ; t7 _3 c# ~6 W4 p5 k! b, D! C* q
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 
    + a9 ]- [/ n4 t/ e$ \' k' F
18.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    
19.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
    9 y$ F; m3 [( }1 K8 k( u
20.         GPIO_SetBits(GPIOA,GPIO_Pin_8);                                                
    7 K) a9 p3 Z  Z$ N
21. }
    ; b! N7 f. {* ]( j6 S1 v8 l
22. 
    
23. 
    : H, K5 ]% ~: }! i% W7 F
24. void TIM2_Init(u16 arr,u16 psc)
    , I* e6 F' w9 h
25. {                                                         
    " [. d% O. t9 o1 F) e
26.         GPIO_InitTypeDef GPIO_InitStructure;
    3 ?. a& I1 z1 x' d, @! }3 L# M" t
27.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    
28.         TIM_OCInitTypeDef  TIM_OCInitStructure;
    : U, J5 z0 y" ]9 s3 K+ l
29.         NVIC_InitTypeDef NVIC_InitStructure;
    / _/ g; P- \7 ?7 T& u% W& R2 a1 h3 n9 u
30. 
    
31.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);         
    7 G8 h8 s+ P0 o9 |
32.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);                                                                              
    * h; W+ K7 G0 V4 L
33. 
    3 @# ~5 A/ S( {: \8 b
34.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                                //TIM2_CH2
    
35.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                        
    9 L- ^8 k; Q+ u3 A! e0 Q* h# z
36.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
37.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
38.         
    " i+ y  n, Y: x6 c( o' H$ ~( {
39.         TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
    3 z' u; L' Y! \& _
40.         
    
41.         TIM_TimeBaseStructure.TIM_Period = arr;                                         
    9 Y8 ]) [4 G2 y- u2 l7 H  W/ V/ E
42.         TIM_TimeBaseStructure.TIM_Prescaler =psc;                                
    
43.         TIM_TimeBaseStructure.TIM_ClockDivision = 0;                        
    & M' ^4 W$ T& N% t8 x" E) N
44.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
45.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);                 
    
46.         TIM_ClearITPendingBit(TIM2,TIM_IT_Update);                                
    
47. 
    
48.         TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Regular);
    & S6 D& v8 X* D8 O5 J! V0 j
49.         TIM_SelectOnePulseMode(TIM2,TIM_OPMode_Single);                        
    ! i; Q: ?) y* l2 N# a+ q( w9 X
50.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;               
    
51.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    - i( G1 C- d; `! |  ~
52.         TIM_OCInitStructure.TIM_Pulse = arr>>1;                                 
    7 n/ @4 @) a  `; W
53.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    % Q5 j* z4 s; Z$ b# |  B2 L1 D
54.         TIM_OC2Init(TIM2, &TIM_OCInitStructure);                                 
    ( d2 V' D- C3 C: s$ \9 l
55. 
    5 q$ ~- W( ]; p: {7 `
56.         TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);                  
    
57.         TIM_ARRPreloadConfig(TIM2, ENABLE);                                         
    ) s5 f( P# C  r
58.         
    
59.         TIM_ITConfig(TIM2, TIM_IT_Update ,ENABLE);                          
    ) e! H; m/ X7 _% Y" _! b0 R8 r
60. 
    
61.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                  
    4 Q$ B; i1 e4 G( a2 V- I
62.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
    ' A% ?( ^  T# k$ h7 C
63.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                 
    
64.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         
    
65.         NVIC_Init(&NVIC_InitStructure);                                                  
    * \8 c5 f0 P2 S( k& q
66.         
    
67.         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);                          
    
68.         TIM_Cmd(TIM2, DISABLE);                                                                                                                           
    
69. }
    2 `# Y, F. A4 j7 m
70. /******* TIM2*********/
    
71. void TIM2_IRQHandler(void)
    
72. {
    
73.         if(TIM_GetITStatus(TIM2,TIM_FLAG_Update)!=RESET)
    ' u3 x8 k& M( B, V
74.         {
    & ~! H5 t  t' u
75.                 TIM_ClearITPendingBit(TIM2,TIM_FLAG_Update);        
    
76.                 count[0]++;
    
77.                 TIM_GenerateEvent(TIM2,TIM_EventSource_Update);
    * u1 P! V0 ~# s$ r9 l
78.         
    7 M! m8 ~; M; t0 f
79.                 TIM_Cmd(TIM2, ENABLE);                                            
    
80. 
    - H/ h# a& B: {
81.                 if(count[0]==200)
    ! l3 A2 v$ m% L+ G' j3 [
82.                 {
    
83.                         if(motor_dir2==CW)                                                   
    . B0 W# }0 ?! N& |6 J* Y. o# i$ s
84.                                 current_pos[0]+=count[0];
    / p0 M0 }9 n" k* A% S
85.                         else                                                                    
    
86.                                 current_pos[0]-=count[0];
    2 {9 ?) P5 R& J! k  Q
87.                         TIM_Cmd(TIM2, DISABLE);                                                   
    
88.                         printf("motor2µ±Ç°Î»ÖÃ=%ld\r\n",current_pos[0]);
    
89.                         count[0]=0;
    ' G; v2 n4 _; i1 ]- J) d8 y0 v
90.                 }
    5 M( B) Q* A5 ^( f1 S
91.         
    
92.         }
    & |" |0 K, ?4 o0 O' K
93. }
    " I& G$ ]% }2 R0 @
94. 
    
95. void TIM2_Startup(u32 frequency)   
    
96. {
    3 |! J! g5 U& B, |
97.         u16 temp_arr=1000000/frequency-1;
    
98.         TIM_SetAutoreload(TIM2,temp_arr);
    
99.         TIM_SetCompare2(TIM2,temp_arr>>1);
    
100.         
     1 U( {0 B+ I( o) Q# f" G
101.         TIM_SetCounter(TIM2,0);
     
102.         TIM_Cmd(TIM2, ENABLE);  
     
103. }
     
104. 
     4 e; Y/ v5 {1 k( _+ d$ U, |% ]
105. 
     2 G5 G* `; c4 l$ X5 \9 \
106. void Locate_Rle2(u32 frequency,DIR_Type dir)
     
107. {
     
108.         
     1 k0 t+ d8 O2 [
109.         if(TIM2->CR1&0x01)
     * f: _& @+ c7 g' d6 F' x  d
110.         {
     
111.                 printf("\r\nThe last time pulses is not send finished,wait please!\r\n");
     " n. M0 y' x1 r1 L" y0 Z3 `3 X! ^
112.                 return;
     
113.         }
     0 Z. z& A* |( T- Y$ J0 ?1 P
114.         if((frequency<20)||(frequency>100000))
     3 E9 T3 V% R8 H+ v: [# z7 ]2 ~
115.         {
     
116.                 printf("\r\nThe frequency is out of range! please reset it!!(range:20Hz~100KHz)\r\n");
     
117.                 return;
     - _  c5 }, V: c8 A2 K* h2 d. y6 o
118.         }
     
119.         motor_dir2=dir;
     & E9 w9 Z- o7 {7 T
120.         
     6 j. C+ U! V( S
121.         DRIVER_DIR2=motor_dir2;                                
     7 O; T& M! u. G! v) _# u) O
122.         TIM2_Startup(frequency);                        
     * c. S4 V! M2 o" B5 ?- q2 ?
123. }
     * N4 ]) S# y" t' Q4 N

复制代码

到这里你就会发现其实原理还是相当简单的，剩下的也不再深入了，希望能够对大家帮助哈哈
; t: T& I& w" \, @
6 P* [0 x& Y- a; Y5 ~2 F实现目的：
3 K/ ?( t1 _: X" G
该程序就是实现正转后隔一会再反转，大家可以根据自己需求设置到自己想要的转动情况，同时要让他停下来，只需要在自己需要的地方设置一个TIM_SetCompare2（TIM2,0）即可停下，可以自由设置。

/ C8 Q; s' C7 h- D% q四、总结
2 [8 V- F2 f$ n# v4 E& U) ?; J今天关于步进电机就暂且介绍到这里，后面有需要会再特别介绍一下，文章写得还是比较简单，相信对于你还是可以很轻松入手的
, [0 W% Y" x3 |  c& i7 z