步进电机特点：

• 它是通过输入脉冲信号来进行控制的
• 电机的总转动角度由输入脉冲数决定
• 电机的转速由脉冲信号频率决定
  
  
  
    C+ W4 |1 P' _) y  `( d. S

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

6 |2 b; I" x8 b8 a! z8 U# S- u步进电机在工业机器人中的应用

步进电机相关概念：

• 拍数
  完成一个磁场周期性变化所需脉冲数或导电状态用n表示，或指电机转过一个齿距角所需脉冲数，以四相电机为例，有四相四拍运行方式即AB-BC-CD-DA-AB，四相八拍运行方式即A-AB-B-BC-C-CD-D-DA-A。
• 步距角
  控制系统每发一个步进脉冲信号，电机所转动的角度。现在市场上常规的二、四相混合式步进电机基本步距角都是1.8°。
  
  ' T# @# S0 @+ @6 ^, g

- V1 A% }# ]9 s相关问题：

问题：有一步进电机参数，如下：
0 A( b+ f, N# Y1 e/ n0 c! b [电压 12VDC  
  n, B* ?6 B0 a" d* \3 d 相数 4  
& Q+ q! a3 W" E$ ?4 Y' f; _ 减速比 1/64  
# i, d1 T! Z. E$ v% v$ q6 B 步距角 1.8° /64
驱动方式 四相八拍 ]
请问： 步距角1.8°/64 ，后面的 “/64”表示什么意思？此步进电机转一圈，要多少步？

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

---

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

& T* ~  L/ K2 c0 JL298N主要参数说明

• 控制信号供电：直流5V；
• 电机供电：直流3V~46V（建议使用36V以下）
• 最大工作电流：2.5A
• 额定功率：25W
• 控制信号输入电压范围：
  
  
  • 低电平：-0.3V <= Vin <= 1.5V
  • 高电平：2.3V <= Vin <= Vss
    
    % ^( U; x1 \+ Z" l. r9 B
• 使能信号输入电压范围：
  
  
  • 低电平：-0.3V <= Vin <= 1.5V（控制信号无效）
  • 高电平：2.3V <= Vin <= Vss（控制信号有效）
    
    
• L298N芯片的输入电压有两个:

  如果步进电机为5VDC供电，那么VSS和VS可以短接到一起；
  + _1 }1 g  c2 w/ e: |3 \/ o+ GVSS和VS两个电源要共地；
  ( R. y7 [1 Q; @. L* A" Y" A* w* {L298N使用的过程中，发热较大，最好添加散热片。

  
  
  
  # P- [- U" K0 |" Y& X
  • VSS：逻辑电压，提供逻辑器件的电源，允许4.5~7V，建议为5V。
  • VS：小于或等于46V，供给电机，和L298内部输出端的工作电源，根据电机的额定电压来接。
    
    

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

8 t/ [7 m5 X/ u0 N! m

L298N原理图

应用实例

& l! R. X  F: }6 C( L  @" L4 P  G- z  }

驱动步进电机

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

  |- k$ o8 ~7 z6 ]程序中使能ENA和ENB之后，令StepMotor_OUT1~StepMotor_OUT4按四个状态变化，时序控制如下图所示，即可控制步进电机的方向：

7 |/ h* l3 a' r) {5 U. r

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

1. 
   9 h3 a: g8 {- f# e* B  f
2. void StepMotor_Init(void)
   5 h+ L: h: Z* l* @
3. {
   
4.         GPIO_InitTypeDef  GPIO_InitStructure;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);       //使能PB,PC端口时钟
   
6.         
   
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;
   4 O3 e, F# K& h8 D' m5 K
10.         GPIO_Init(GPIOC, &GPIO_InitStructure);
    : X' Q( P8 G( {; W& E% j: ~
11.         GPIO_SetBits(GPIOC,GPIO_Pin_6);
    2 l4 P9 _( {% h+ p% T, y" r
12.         GPIO_SetBits(GPIOC,GPIO_Pin_7);
    
13.         
    
14.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
    # `0 e5 a, q6 J( f) i2 b3 \4 }
15.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
17.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
18. 
    
19.         L298D_1AA = 0;
    $ @' L' q2 k3 s
20.         L298D_2AA = 0;
    4 t/ B* Q) b7 [% u' T5 K
21.         L298D_3AA = 0;
    & c, S5 Z, F& U7 z
22.         L298D_4AA = 0;
    8 X' j9 X. I% a5 _& B
23.         L298D_12ENA = 0;
    
24.         L298D_34ENA = 0;
    , N2 X( a7 q7 }3 T5 B7 o) |
25. }

复制代码

3 p3 Z. k' h. u( A# A7 X. c  M! O
2. 两相电机驱动代码，包括正转和反转

1. 
   , h6 M2 G; R1 E6 M6 W- C' O- q
2. void TwoPhaseMotor(unsigned char nInputData ,unsigned char nDirection)
   
3. {
   : A7 K, E5 x* ~% X8 i4 n
4.         if(1 == nDirection)             //逆时针
   7 ^7 W4 f# Y/ \" J5 z, Y. K9 I4 M& I
5.         {
   
6.                 switch(nInputData)
   
7.                 {
   
8.                         case 1:
   ; O, F+ ~- H: [4 ^) k2 u( [
9.                         {
   8 R. Z8 P. `' |5 d! R7 Y
10.                                 L298D_1AA = 0;
    9 \& I) v  X7 @
11.                                 L298D_2AA = 1;
    
12.                                 L298D_3AA = 0;
    
13.                                 L298D_4AA = 1;
    
14.                         }
    
15.                         break;
    
16.                         case 2:
    
17.                         {
    
18.                                 L298D_1AA = 0;
    7 s& W/ L( U' ?! B! ^! c
19.                                 L298D_2AA = 1;
    
20.                                 L298D_3AA = 1;
    2 P# V5 d+ J! I
21.                                 L298D_4AA = 0;
    , K3 x: S) q# L9 J
22.                         }
    
23.                         break;
    
24.                         case 3:
    ! o, V" y. g1 \# h5 T1 T
25.                         {
    + L) ?6 C- T4 I. L% h
26.                                 L298D_1AA = 1;
    
27.                                 L298D_2AA = 0;
    
28.                                 L298D_3AA = 1;
    ' G; y5 Z/ a, s- D. M$ t: J
29.                                 L298D_4AA = 0;
    
30.                         }
    
31.                         break;
    * Y; }: O# R) f4 }8 l+ C
32.                         case 4:
    
33.                         {
    
34.                                 L298D_1AA = 1;
    : w0 p+ {. L8 D* U8 ~
35.                                 L298D_2AA = 0;
    ) H, \- ]. Q3 b' C
36.                                 L298D_3AA = 0;
    / x8 X2 j) U# [
37.                                 L298D_4AA = 1;
    ( P& h: C% g7 X' d
38.                         }
    
39.                         break;
    / m: A  {& t' j4 W# c: l$ z+ w
40.                 }
    
41.         }
    
42.         else if(0 == nDirection)        //顺时针
    + e1 \% G/ {# [" R# h: B) W  j/ ^
43.         {
    
44.                 switch(nInputData)
    
45.                 {
    6 N+ n, t( D2 a  G/ E- d- M% f
46.                         case 1:
    . T) J9 I2 x" ~' N& U# C, N: {
47.                         {
    
48.                                 L298D_1AA = 1;
    
49.                                 L298D_2AA = 0;
    
50.                                 L298D_3AA = 0;
    
51.                                 L298D_4AA = 1;
    3 g  S* b9 P/ \9 e$ [7 Z( f9 d# P8 B
52.                         }
    
53.                         break;
    ! A+ y; ^6 q1 ~  X
54.                         case 2:
    
55.                         {
    2 D; k# b, C* R9 h0 Y+ Z1 o
56.                                 L298D_1AA = 1;
    8 ?" q: `, E$ l$ _* u: k; u0 _
57.                                 L298D_2AA = 0;
    / I( c9 H5 a) h( o
58.                                 L298D_3AA = 1;
    " v$ i# [6 q/ k' A) v
59.                                 L298D_4AA = 0;
    . i/ E+ O4 n$ R0 H( D) s
60.                         }
    
61.                         break;
    / i6 u' K$ p& k5 a0 X
62.                         case 3:
    
63.                         {
    " S4 K$ F+ r7 l/ {+ v4 J
64.                                 L298D_1AA = 0;
    
65.                                 L298D_2AA = 1;
    
66.                                 L298D_3AA = 1;
    % F6 O( q+ G4 E4 p3 n4 @1 S& `
67.                                 L298D_4AA = 0;
    ! z! J  s+ L# |2 h9 f+ E
68.                         }
    ; _( g  L; I3 H) y1 d
69.                         break;
    ' o; `9 M  Q1 }3 p. f
70.                         case 4:
    
71.                         {
    
72.                                 L298D_1AA = 0;
    $ K+ g# M) I# |
73.                                 L298D_2AA = 1;
    
74.                                 L298D_3AA = 0;
    6 w1 J5 K& w( a( Y
75.                                 L298D_4AA = 1;
    * g6 X! ~- M6 ]) J
76.                         }
    
77.                         break;
    ) H% |$ b, N% R8 U
78.                 }
    ' m$ q1 }! n3 |3 W& p! X6 t- _
79.         }
    6 V2 m) l, G1 r; D8 g7 P  @( b8 y
80. }

复制代码

. A8 d* a" G' i8 l

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

1. 
   
2. void TwoPhaseMotorNCircle(int n,unsigned char direction)
   
3. {
   
4.     int i,j;
   5 P% ?0 x3 w9 u1 y& D
5.         
   4 O; l+ v* T# }% [( N
6.     L298D_12ENA = 1;    //只有转的时候使能，否则持续供电，芯片和电机过热。
   - H% ~1 T7 o3 ?8 Q, z# G8 e
7.     L298D_34ENA = 1;
   6 p  ~$ L( X' ?! J. _6 y; V  \
8.    
   
9.     for(i=0;i<n;i++)
   
10.     {
    + n+ p2 {9 }4 _% {1 a( M
11.         for(j=1;j<=4;j++)
    . D/ `7 j1 D/ l1 ?: @# C% u2 ?
12.         {
    
13.             TwoPhaseMotor(j,direction);
    $ `2 f8 c( a9 S" H9 u8 j, u, v/ q
14.             delay_ms(2);
    
15.         }
    6 A, o% W5 Q0 l. R8 n
16.     }
    3 U0 T. F# g6 \2 y: l
17.    
    9 v/ q4 a, `2 ]' B
18.     L298D_12ENA = 0;
    
19.     L298D_34ENA = 0;
    1 Z& c# }7 ]2 r+ y
20. }

复制代码

3. 主函数中调用说明：

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

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

主函数代码如下：
& S  H0 B/ T1 g2 |3 f$ h

1. 
   # A) _8 u. I( }
2. int main(void)
   
3. {
   8 s9 `0 I$ y2 ]% j0 I
4.         //解析payload数据包使用
   
5.         cJSON *receive_json, *item_obj;
   
6.          
   ' K/ [. v/ r& F" `. u
7.         u16 i;
   . }' v. m) O& \4 L
8.         u16 uart2Len=0;
   ( h8 `' `0 z6 N5 }
9.          
   + U/ _  ^$ i9 M/ V9 k
10.         u8 dtbuf[50];   //打印缓存器
    
11.                  
    
12.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
13. 
    
14.         USART2_RX_STA=0;
    
15.         memset(USART2_RX_BUF, 0, sizeof(USART2_RX_BUF));
    & @9 d9 ?3 b+ ?
16.         
    , o# l/ a: Y. X4 _3 b3 Z
17.         memset(dtbuf,'\0',50);
    
18. 
    
19.         //初始化
    : x9 D% A5 Q$ u
20.         //延时函数初始化
    
21.         delay_init();
    
22.                   
    
23.         uart_init(115200);                      //串口1:Debug,初始化为115200
    
24.         uart2_init(115200);
    
25.         
    9 |! e& L6 R" }' M. a( c' v
26.         //定时器3,--步进电机使用
    
27.         TIM3_Int_Init(99,7199);         //1ms中断
    2 K( c* N7 ]( ?, D5 h; {
28.         TIM3_Set(0);
    ( q' h2 k# C. u  X8 C
29. 
    
30.         StepMotor_Init();
    ) ^4 R$ Y* G% w4 g0 c
31.         
    / T' d1 ]& P; ~4 e5 @
32.         printf("System Init OK \r\n");
    
33.         
    ) G- R/ i! o$ |2 x
34.         //主循环
    
35.         while(1)
      D1 p0 E: e+ i+ e) d# x
36.         {
    % z( F, A+ g6 ~" }0 U5 b- F
37.                 //ESP8266
    3 v8 Q& }& _7 X# b6 r* h4 c
38.                 if(USART2_RX_STA&0x8000)
    " g2 V* u/ N0 z) W
39.                 {
    # L% z9 Y* x$ i' T1 @1 V1 R; F
40.                         uart2Len=USART2_RX_STA&0x3f;
    
41.                     
    3 A) N4 ?4 s7 x  @" R- ?$ s# T
42.                         receive_json = cJSON_Parse(USART2_RX_BUF);      //创建JSON解析对象，返回JSON格式是否正确
    + ?2 R) c. d: P
43.                         if (!receive_json)
    : r$ k, A2 L! {% l$ ~
44.                         {
    
45.                                 printf("JSON格式错误:%s\r\n", cJSON_GetErrorPtr()); //输出json格式错误信息
    
46.                         }
    
47.                         else
    
48.                         {
    
49.                                 printf("JSON格式正确:\n%s\r\n",cJSON_Print(receive_json) );
    $ V: G; {& R: H9 H5 c2 w, P
50.                                 item_obj = receive_json->child; //获取name键对应的值的信息
    
51.                                 
    9 Q7 k! r8 X/ ^$ b3 {8 \3 J. h. t0 M
52.                                 while(item_obj)
    7 F  L1 v. u" ?, }+ X$ I, W
53.                                 {
    2 ?6 a/ w" n3 N) z) ^. ~% u2 Q2 [+ P
54.                                         char * string = item_obj->string;
    
55.                                        
    
56.                                         if(!strcmp(string,"PowerSwitch"))
    
57.                                         {
    
58.                                                 if(item_obj->valueint==1)
    
59.                                                 {
    ( a: X* [5 y5 P) `  F
60.                                                         L298D_12ENA = 1;        //只有转的时候使能，否则持续供电，芯片和电机过热。
    0 I4 R1 ?$ q  H4 ~" A7 u
61.                                                         L298D_34ENA = 1;
    9 o7 n; j5 ?0 Z% v0 J- u
62.                                                         
    * M8 t: ^; Q/ C+ f" T3 }
63.                                                         TIM3_Set(1);
    " Y9 O* h! ?+ R" ?. b" `# Y
64.                                                         
    4 l( t  L2 Q5 {2 M% `
65.                                                         nRotationCounting = 0;
    2 r4 v. z5 g/ Z2 c& M
66.                                                         
    . P7 \- L( A- E+ n8 K7 i
67.                                                         stuAliOSIoT.PowerSwitch = 1;
      ^) f8 A# R4 x& L2 O  y( ?- L" h
68.                                                         
    
69.                                                         printf("PowerSwitch:1\r\n");
    & N. s; N  Q+ j0 f3 u2 P% T9 r  C
70.                                                 }
    
71.                                                 else if(item_obj->valueint==0)
    
72.                                                 {
      A: v# I$ @' w) ]% H2 k* _- z
73.                                                         //步进电机运动停止
    
74.                                                         L298D_12ENA = 0;
    
75.                                                         L298D_34ENA = 0;
    
76.                                                         
    8 ^5 l* N4 e8 J. ]) |& p: W# P
77.                                                         TIM3_Set(0);
    ( `' O; R; [) |& E
78.                                                         
    
79.                                                         stuAliOSIoT.PowerSwitch = 0;
    3 o! c7 @/ q" Z7 s
80.                                                         
    
81.                                                         printf("PowerSwitch:0\r\n");
    - E) H2 h2 h+ [. w
82.                                                 }
    & \6 H* [: z( c) l# a3 F
83.                                         }
    7 G, B- C& C7 k4 C/ j
84.                                        
    
85.                                         item_obj = item_obj->next;
    
86.                                 }
    ; t; O) h+ H- j0 Q- K& P
87.                                 
    
88.                                 cJSON_Delete(receive_json);
    + u& n9 w6 a' y2 I. s2 o
89.                                 
    
90.                         }
    ) j6 F8 c: d% d1 h" j9 B$ \6 u
91.                         
    
92.                         USART2_RX_STA=0;
    2 q, h. D5 m4 X/ e5 F, N# L# g
93.                         memset(USART2_RX_BUF, 0, sizeof(USART2_RX_BUF));   //清空数组
    0 L! k- ^5 e: Q
94.                 }
    
95.                                 
    ) d6 J1 E. K- Y" ?: m. [
96.                 delay_ms(10);
    
97.         }
    8 l# K) C: Q0 m7 A) r
98.         
    + e6 j5 A3 R0 e% O$ a: G, A
99. }

复制代码

定时器中代码如下：

1. 
   $ a0 P& R- w, n+ x' {2 u
2. //定时器3中断服务程序
   ) ?) N$ E" ?: D0 F  [7 z, [& y
3. void TIM3_IRQHandler(void)
   2 @% Q, U$ U. Q: f2 p8 b2 l
4. {
   + Q" V4 G; S% L$ v7 Y& s9 r
5.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//是更新中断
   
6.         {
   , r- }0 w0 [  B; O, G
7.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIM3更新中断标志
   3 s% C8 r9 q& w: A4 w( {
8.                
   6 j8 z3 A) N- A. }1 Q  i! T
9.                 nRotationCounting++;
   
10.                 if(nRotationCounting > nSingleCycleDataPoints)
      |7 W2 c0 I0 B$ c* W
11.                 {
    
12.                         if(nRotationDirection==0)
    # @* E+ `" E. i$ Y1 i2 b% i
13.                         {
    : X: S/ ^5 E- o+ A8 t9 {1 ~4 ]) B
14.                                 nRotationDirection=1;
    ; l8 g! F5 o; O8 {; T2 g
15.                         }
    
16.                         else if(nRotationDirection==1)
    
17.                         {
    4 v' t: Z: _  i$ {& X
18.                                 nRotationDirection=0;
    * Z- ^: Q" e( D' a* v9 _
19.                         }
    
20.                         
    . [: ]0 h. p' J
21.                         nRotationCounting=0;
    
22.                 }
    
23.                
    
24.                 if(stuAliOSIoT.PowerSwitch)
    
25.                 {
    ' e% f8 u% B+ D8 y
26.                         if(nRotationDirection==0)                       //正转
    / ]+ p6 L. a3 c( u! O7 f( Q
27.                         {
    ) l/ ], o1 T. C9 H
28.                                 TwoPhaseMotor(nRotationCounting%4+1,0);                         //顺时针
    . o& u1 v( l2 L1 c* c% [1 J3 v
29.                         }
    
30.                         else if(nRotationDirection==1)          //反转
    ' u: f/ R: o8 N" O8 K  d3 P
31.                         {
    
32.                                 TwoPhaseMotor(nRotationCounting%4+1,1);
    
33.                         }
    
34.                 }
    
35.                
    6 u; P3 u. t! V& l7 |  s
36.                 //TIM_Cmd(TIM3, DISABLE);  //关闭TIM3
    & k: R. U/ u; T# u1 N. j6 \; i
37.         }
    
38. }

复制代码

  ?' M& {" e* l  i实物图

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

  l( _% i$ N% `+ X! f/ `/ t- }8 s9 ~
% Z4 W; W6 }" e/ m  j