步进电机特点：

• 它是通过输入脉冲信号来进行控制的
• 电机的总转动角度由输入脉冲数决定
• 电机的转速由脉冲信号频率决定
  
  
  
  

步进电机主要用于一些有定位要求、进行精确控制的场合。特别适合要求运行平稳、低噪音、响应快、使用寿命长、高输出扭矩的应用场合。比如3D打印机、工业机器人等场景。

, j) x' q- g+ ^步进电机在工业机器人中的应用

% c8 h: I1 {: e9 x8 A步进电机相关概念：

• 拍数
  * K% z% B, F9 ?4 J; |$ m完成一个磁场周期性变化所需脉冲数或导电状态用n表示，或指电机转过一个齿距角所需脉冲数，以四相电机为例，有四相四拍运行方式即AB-BC-CD-DA-AB，四相八拍运行方式即A-AB-B-BC-C-CD-D-DA-A。
• 步距角
  6 d$ O2 z- }# T+ o3 x. X控制系统每发一个步进脉冲信号，电机所转动的角度。现在市场上常规的二、四相混合式步进电机基本步距角都是1.8°。
  
  % a9 Y* F3 X" W# ^

1 M% k+ u- U) R/ u1 _7 O  p+ ~相关问题：

问题：有一步进电机参数，如下：
. A8 o) n/ ?, h5 x9 Q6 ], G6 O6 e! v [电压 12VDC  
相数 4  
2 ^, R5 C4 h% m5 \ 减速比 1/64  
' j" V; B: T/ n  ` 步距角 1.8° /64
( v2 Q  t7 Z- J* M6 ~ 驱动方式 四相八拍 ]
请问： 步距角1.8°/64 ，后面的 “/64”表示什么意思？此步进电机转一圈，要多少步？

答案：12VDC的步进电机，L298N的VS接12V直流电源。步进电机本身到电机轴之间是有一级齿轮减速的，64指减速比，即：电机本身的转子转64圈，输出的电机轴才转1圈。步距角1.8° /64表示，每走动64拍，转过角度为1.8度，转一圈共需要(360/1.8)*64=12800拍(步)

---

1 w! u& c/ T4 `; f9 U

若是新手，不知道怎么设计电机驱动电路，可以直接购买电机驱动模块，市面上这种功能模块非常多，比如L298N电机驱动模块，只需要单片机6个IO外加一个电机供电电源即可驱动步进电机。

L298N主要参数说明

• 控制信号供电：直流5V；
• 电机供电：直流3V~46V（建议使用36V以下）
• 最大工作电流：2.5A
• 额定功率：25W
• 控制信号输入电压范围：
  
  . S) P6 q" T+ T4 f  l0 `
  • 低电平：-0.3V <= Vin <= 1.5V
  • 高电平：2.3V <= Vin <= Vss
    
    7 T' R  J5 `5 U+ E" p9 {
• 使能信号输入电压范围：
  
  
  • 低电平：-0.3V <= Vin <= 1.5V（控制信号无效）
  • 高电平：2.3V <= Vin <= Vss（控制信号有效）
    
    
• L298N芯片的输入电压有两个:

  如果步进电机为5VDC供电，那么VSS和VS可以短接到一起；
  VSS和VS两个电源要共地；
  0 }6 b( x6 L8 B; c6 YL298N使用的过程中，发热较大，最好添加散热片。

  
  
  
  # h! o' H" S! ^* M
  • VSS：逻辑电压，提供逻辑器件的电源，允许4.5~7V，建议为5V。
  • VS：小于或等于46V，供给电机，和L298内部输出端的工作电源，根据电机的额定电压来接。
    
    : L6 l( C; f/ f! u( j

如果想自己设计电路实现电机的驱动，可以参考如下电路。

* i6 ?1 l, E* u9 x

L298N原理图

0 T# r/ P. N4 f3 j5 S应用实例

4 S, ^1 J! }/ n5 F

驱动步进电机

驱动四线两相电机，四个状态为1、AB正电压；2、A-B正电压；3、A-B-正电压；4、AB-正电压。

% i# Y. o/ G/ q/ X$ G- ^程序中使能ENA和ENB之后，令StepMotor_OUT1~StepMotor_OUT4按四个状态变化，时序控制如下图所示，即可控制步进电机的方向：

实现代码1. 驱动步进电机的引脚初始化

1. 
   
2. void StepMotor_Init(void)
   
3. {
   0 g7 }# K. z0 f4 o
4.         GPIO_InitTypeDef  GPIO_InitStructure;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);       //使能PB,PC端口时钟
   . b- I* {- V8 X- N& T
6.         
   $ `4 Q. C: T( n  s' G$ x7 m
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
   
8.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   
9.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   8 [9 v7 t  _1 G* T! Z* _
10.         GPIO_Init(GPIOC, &GPIO_InitStructure);
    
11.         GPIO_SetBits(GPIOC,GPIO_Pin_6);
    ; A9 _: f1 k* i2 D' E
12.         GPIO_SetBits(GPIOC,GPIO_Pin_7);
    
13.         
    ) n4 |7 u3 s+ Q
14.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
    
15.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    2 y" G. D4 @+ q* @
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    4 p( d9 V9 Z" y# Q- a
17.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
18. 
    
19.         L298D_1AA = 0;
    
20.         L298D_2AA = 0;
    7 `- b1 _9 @9 C9 |
21.         L298D_3AA = 0;
    / w/ Y" @. J; z$ L! f/ v
22.         L298D_4AA = 0;
    
23.         L298D_12ENA = 0;
    
24.         L298D_34ENA = 0;
    ! T8 n* A$ T' _; m! j1 b0 n! ~
25. }

复制代码

8 o, s! o, Q- ~' \( Q# g9 `% [
& M0 b- l+ c8 n- U$ ]" I/ A5 m2. 两相电机驱动代码，包括正转和反转
0 m: b) n* i% Y7 K, h* V

1. 
   
2. void TwoPhaseMotor(unsigned char nInputData ,unsigned char nDirection)
   ! ?6 O; o) p4 P' }" j, i
3. {
   " G- {% ~' h& Q- [( |# }8 D
4.         if(1 == nDirection)             //逆时针
   ' U! k; _% b) s, i0 B; G
5.         {
   6 t4 h/ A: `- n0 j; _% C9 F9 k
6.                 switch(nInputData)
   
7.                 {
   
8.                         case 1:
   2 I+ X+ {& O2 n4 k% d1 f
9.                         {
   
10.                                 L298D_1AA = 0;
    % j3 S$ L' \& R' k5 |
11.                                 L298D_2AA = 1;
    * D  N3 E+ q) [: a8 z' F9 U4 L/ {
12.                                 L298D_3AA = 0;
    
13.                                 L298D_4AA = 1;
    7 g; u, \8 e( n: |- J7 I
14.                         }
    
15.                         break;
    
16.                         case 2:
    
17.                         {
    
18.                                 L298D_1AA = 0;
    
19.                                 L298D_2AA = 1;
    
20.                                 L298D_3AA = 1;
    . ~7 P& [! c2 K4 S' G
21.                                 L298D_4AA = 0;
    6 l6 X& X; }5 `3 f3 ^9 l
22.                         }
    
23.                         break;
    % P  s8 f4 n. s
24.                         case 3:
    # [# r7 I1 h! P- \
25.                         {
    
26.                                 L298D_1AA = 1;
    
27.                                 L298D_2AA = 0;
    
28.                                 L298D_3AA = 1;
    ' G! C4 Q$ R3 m, L
29.                                 L298D_4AA = 0;
    * l3 q/ T, O# D" V% F7 V
30.                         }
    1 v# x+ W( P0 r
31.                         break;
    . l2 d4 l/ t' @4 _$ ^4 q4 Y
32.                         case 4:
    
33.                         {
    ) ~! B8 n9 f! @7 \, X
34.                                 L298D_1AA = 1;
    # l9 l# `1 n6 Q9 K
35.                                 L298D_2AA = 0;
    " K. C5 b; Y  s3 B. s; q7 r/ ?
36.                                 L298D_3AA = 0;
    
37.                                 L298D_4AA = 1;
    
38.                         }
    
39.                         break;
    4 c& {& M) J- n) h. a+ i
40.                 }
    
41.         }
    ! M& {* |$ `- P' V2 K4 J
42.         else if(0 == nDirection)        //顺时针
    , E! m; I$ z$ J3 d* Z" w
43.         {
    5 }( x. q: i7 Y9 l3 J3 x8 U1 q6 n2 j
44.                 switch(nInputData)
    - z8 F5 M3 }8 |2 J' s) }
45.                 {
    + J# |! m9 D, V0 X) _7 X4 F+ z& P
46.                         case 1:
    0 w, _" Q. ]7 V3 b/ A7 m. o
47.                         {
    
48.                                 L298D_1AA = 1;
    
49.                                 L298D_2AA = 0;
    
50.                                 L298D_3AA = 0;
    7 x6 o$ b$ Q% a( [0 O' B5 i5 I/ r
51.                                 L298D_4AA = 1;
    6 W( `& c0 g* F
52.                         }
    , B0 H5 y1 d# q1 j* w
53.                         break;
    
54.                         case 2:
    1 d$ n9 z$ c" i5 S
55.                         {
    
56.                                 L298D_1AA = 1;
    $ l4 c% P1 S3 d$ _, ]
57.                                 L298D_2AA = 0;
    # i6 W* @6 a2 @( c/ P
58.                                 L298D_3AA = 1;
    
59.                                 L298D_4AA = 0;
    
60.                         }
    4 [4 p% C% ~6 I4 }8 C
61.                         break;
    " C6 R1 y8 [9 [( p/ t: b
62.                         case 3:
    
63.                         {
    $ t; N) S& G* L' J" @- y3 |2 m5 H- k
64.                                 L298D_1AA = 0;
      ~5 L7 v. P# |- ?. {
65.                                 L298D_2AA = 1;
    - ~8 L. f" K$ R( x3 V% ^3 ~: y; r
66.                                 L298D_3AA = 1;
    
67.                                 L298D_4AA = 0;
    / o9 |4 h- `9 q8 N+ g
68.                         }
    
69.                         break;
    6 v$ S/ e) h4 r+ y# s
70.                         case 4:
    ; S6 X, g6 Y# }7 l
71.                         {
      X) [5 R- G, t3 n+ j
72.                                 L298D_1AA = 0;
    6 r8 W. C& V! r% A2 w& p0 G
73.                                 L298D_2AA = 1;
    3 B+ |+ o  O7 ]/ ?) C' P$ {+ r+ `. l
74.                                 L298D_3AA = 0;
    & l8 {' e" _- W
75.                                 L298D_4AA = 1;
    : x! ]1 @) a9 g3 x- I
76.                         }
    
77.                         break;
    
78.                 }
    ( X6 ]1 J8 u: E4 i8 v
79.         }
    - a% r' s1 `# p- p: M
80. }

复制代码

1 v- {* r! I0 l& B  g. u" j

上面函数调用一次，步进电机走一步，对上面函数进行封装，既得到走任意步，可控制方向的函数：

1. 
   
2. void TwoPhaseMotorNCircle(int n,unsigned char direction)
   
3. {
   5 [  G, `' i$ X) }& K
4.     int i,j;
   
5.         
   * c' Q. N' u- {" p
6.     L298D_12ENA = 1;    //只有转的时候使能，否则持续供电，芯片和电机过热。
   ! q! A+ ^) ?7 |" ~0 P+ u
7.     L298D_34ENA = 1;
   4 A$ w. _- Z: ]- C* i. {
8.    
   % B+ h; F4 T- i' P3 o
9.     for(i=0;i<n;i++)
   % S9 n( `# T. {* w8 f+ Y  Z
10.     {
    " h) m! U" p" p- d. X0 v
11.         for(j=1;j<=4;j++)
    
12.         {
    
13.             TwoPhaseMotor(j,direction);
    
14.             delay_ms(2);
    
15.         }
    ' M+ B. `9 a% `) J
16.     }
    
17.    
    8 Q& D) c/ l  _% Z
18.     L298D_12ENA = 0;
    , C/ z/ d" p0 w5 s$ D0 m) X
19.     L298D_34ENA = 0;
    # ]' A+ _: G; B
20. }

复制代码

& Q1 @, K7 l+ }  C3. 主函数中调用说明：

• 硬件实现中串口2与ESP8266模块相连，使用cJSON解析收到的阿里云物联网的数据包；
• 收到的{"owerSwitch":1)，电机转动，{"owerSwitch":0}，电机停止；
• 收到电机转动指令之后，此程序让步进电机左转N圈之后，再右转N圈，如此反复，所以为了不影响程序对其他指令的响应，所以将控制步进电机转动的步进代码放到了定时器中执行，主程序中，只控制ENA和ENB的使能开关
  
  " o+ X2 C" I8 q# P, [) U

JSON字符串解析参考之前的网文：Keil环境下STM32工程加入cJSON

主函数代码如下：

1. 
   " v& g  j2 i4 n( A7 k
2. int main(void)
   
3. {
   
4.         //解析payload数据包使用
   
5.         cJSON *receive_json, *item_obj;
   0 ^; B( h, X! C' U4 l
6.          
   0 n  {# C6 i9 }2 r+ I- _  ^
7.         u16 i;
   
8.         u16 uart2Len=0;
   
9.          
   
10.         u8 dtbuf[50];   //打印缓存器
    ! h; ~; t2 ~6 @% i. c
11.                  
    
12.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    , }7 C$ B0 [) E% K4 e# j- [) ~2 q
13. 
    ( g: ^: D; j$ e1 s* l8 c
14.         USART2_RX_STA=0;
    
15.         memset(USART2_RX_BUF, 0, sizeof(USART2_RX_BUF));
    
16.         
    1 f. E- n- j5 \' R1 h3 P
17.         memset(dtbuf,'\0',50);
    
18. 
    
19.         //初始化
    7 |) b2 L( x; C" B
20.         //延时函数初始化
    , s+ A" K3 d2 [
21.         delay_init();
    
22.                   
    
23.         uart_init(115200);                      //串口1:Debug,初始化为115200
    
24.         uart2_init(115200);
    
25.         
    
26.         //定时器3,--步进电机使用
    
27.         TIM3_Int_Init(99,7199);         //1ms中断
    3 n% p. b4 W* C6 M6 K7 J, M) S% x1 E( h
28.         TIM3_Set(0);
    ) s- m5 F- b- n2 _& r0 l
29. 
    
30.         StepMotor_Init();
    
31.         
    
32.         printf("System Init OK \r\n");
    
33.         
    
34.         //主循环
    
35.         while(1)
    : d% s/ s* V8 t3 V
36.         {
    
37.                 //ESP8266
    ! a- J/ L" ]- a+ I
38.                 if(USART2_RX_STA&0x8000)
    : V1 @. \$ Y% K
39.                 {
    
40.                         uart2Len=USART2_RX_STA&0x3f;
    ' F0 w4 H* e* @. d
41.                     
    ) h; v1 B/ N5 m5 ~% w, T* O
42.                         receive_json = cJSON_Parse(USART2_RX_BUF);      //创建JSON解析对象，返回JSON格式是否正确
    8 P9 ]" ]+ g# O" S. m* H
43.                         if (!receive_json)
    
44.                         {
    0 J0 k" d5 ]" f  P  n
45.                                 printf("JSON格式错误:%s\r\n", cJSON_GetErrorPtr()); //输出json格式错误信息
    
46.                         }
    
47.                         else
    
48.                         {
    ) b9 {! ~' v% P1 _# [! }. }
49.                                 printf("JSON格式正确:\n%s\r\n",cJSON_Print(receive_json) );
    . a! o3 q0 Y) J  w. y5 r
50.                                 item_obj = receive_json->child; //获取name键对应的值的信息
    ( j8 ?* w0 ?4 g) m- o: n
51.                                 
    5 s' k/ ]; o. s9 a
52.                                 while(item_obj)
    
53.                                 {
    2 C# `0 d% _" E' E) d
54.                                         char * string = item_obj->string;
    
55.                                        
    1 Y! g" Z6 r5 s/ u1 }3 E) {0 [" i
56.                                         if(!strcmp(string,"PowerSwitch"))
    0 p, ]9 i% I. r/ u
57.                                         {
    & U7 M- `4 l- T+ t! n
58.                                                 if(item_obj->valueint==1)
    
59.                                                 {
    
60.                                                         L298D_12ENA = 1;        //只有转的时候使能，否则持续供电，芯片和电机过热。
    0 A# Q. e; }4 D; s1 y
61.                                                         L298D_34ENA = 1;
    ) d3 M, U5 j% R, n% F' J6 s& k
62.                                                         
    
63.                                                         TIM3_Set(1);
    2 h  ^6 {/ E' z
64.                                                         
    - O- Y/ F# S3 o( k8 @- D* j
65.                                                         nRotationCounting = 0;
    
66.                                                         
    - q! J! q# c) }7 ~) ~2 |; g
67.                                                         stuAliOSIoT.PowerSwitch = 1;
    ' z8 b# `, t" N# h+ d; |( v
68.                                                         
    
69.                                                         printf("PowerSwitch:1\r\n");
    
70.                                                 }
    . c* E- R( A; }* v# k
71.                                                 else if(item_obj->valueint==0)
    
72.                                                 {
    
73.                                                         //步进电机运动停止
    
74.                                                         L298D_12ENA = 0;
    4 K. F& _# C, v- F* u
75.                                                         L298D_34ENA = 0;
    
76.                                                         
    . F% S1 v+ E+ P: p
77.                                                         TIM3_Set(0);
    
78.                                                         
    # c. k1 c5 }9 m
79.                                                         stuAliOSIoT.PowerSwitch = 0;
    
80.                                                         
    
81.                                                         printf("PowerSwitch:0\r\n");
    
82.                                                 }
    
83.                                         }
    6 }# g. P" g5 v# f' b% G
84.                                        
    
85.                                         item_obj = item_obj->next;
    
86.                                 }
    ; ~0 _" B# M0 K9 x' L, @
87.                                 
    1 R% u* s0 m+ W$ w
88.                                 cJSON_Delete(receive_json);
    
89.                                 
    
90.                         }
    + }' d' s. i9 [
91.                         
    . N% C' H: e& _# [9 [
92.                         USART2_RX_STA=0;
    
93.                         memset(USART2_RX_BUF, 0, sizeof(USART2_RX_BUF));   //清空数组
    
94.                 }
    
95.                                 
    ) D; A+ S5 l$ Y3 d8 t! w" Q! ?
96.                 delay_ms(10);
    0 k. R( h5 k& p% Y+ b2 K4 V
97.         }
    & l6 Y9 C' `  X. g. n
98.         
    
99. }

复制代码

定时器中代码如下：

1. 
   
2. //定时器3中断服务程序
   ' ]2 y8 m" R4 R
3. void TIM3_IRQHandler(void)
   + u% V1 c8 y* D  O
4. {
   
5.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//是更新中断
   7 W! h  W% p4 l, r/ M6 p
6.         {
   3 B: m$ Q3 @$ ~% M( D, X
7.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIM3更新中断标志
   
8.                
   ; a' H- A6 A! x0 X% ?
9.                 nRotationCounting++;
   
10.                 if(nRotationCounting > nSingleCycleDataPoints)
    7 q5 c! a/ t0 k& `
11.                 {
    
12.                         if(nRotationDirection==0)
    
13.                         {
    5 `( y  O1 e6 ?  g. U& B  @
14.                                 nRotationDirection=1;
    0 }9 V5 G: E+ ?" J# v2 j
15.                         }
    4 a! p; @% C& X
16.                         else if(nRotationDirection==1)
    
17.                         {
    
18.                                 nRotationDirection=0;
    4 N  w& n3 U% N# C# c+ {7 Y! p/ [
19.                         }
    3 `0 V3 B& Q3 ?- o/ p  R
20.                         
    5 L+ J- ?( P1 U6 {; o$ Q! G
21.                         nRotationCounting=0;
    
22.                 }
    
23.                
    , `' |. \6 l) S9 a; \
24.                 if(stuAliOSIoT.PowerSwitch)
    
25.                 {
    - F5 m1 w& n% C: |$ Z$ L& E
26.                         if(nRotationDirection==0)                       //正转
    . {, S% T& E) n4 P  v6 N
27.                         {
    " ], ~, |! {$ R, [: j" D: d
28.                                 TwoPhaseMotor(nRotationCounting%4+1,0);                         //顺时针
    3 ?6 C1 g- V) c
29.                         }
    
30.                         else if(nRotationDirection==1)          //反转
    
31.                         {
    ' c' I. H2 i6 V+ ^$ A6 [
32.                                 TwoPhaseMotor(nRotationCounting%4+1,1);
    
33.                         }
    9 d/ e$ U/ W# @2 i" L4 I: {8 H
34.                 }
    
35.                
    - \  H( U5 i# ]$ m: K2 {. b
36.                 //TIM_Cmd(TIM3, DISABLE);  //关闭TIM3
    + [4 P& G% |2 G& W: ~
37.         }
    
38. }

复制代码

) y( o* h2 l8 L$ u, \3 r实物图

电源座用于提供外部VS供电；

8 T' d" H9 \1 p* p) T( j6 ^; n