步进电机特点：

• 它是通过输入脉冲信号来进行控制的
• 电机的总转动角度由输入脉冲数决定
• 电机的转速由脉冲信号频率决定
  
  
  
  ' E7 C/ O7 l) [4 |5 H" \, n- }

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

$ d5 l9 b+ J. k  e: y1 N步进电机在工业机器人中的应用

步进电机相关概念：

• 拍数
  - X- t6 f! l4 Z; h+ L) H& d# ^4 e4 x, ~7 Y完成一个磁场周期性变化所需脉冲数或导电状态用n表示，或指电机转过一个齿距角所需脉冲数，以四相电机为例，有四相四拍运行方式即AB-BC-CD-DA-AB，四相八拍运行方式即A-AB-B-BC-C-CD-D-DA-A。
• 步距角
  控制系统每发一个步进脉冲信号，电机所转动的角度。现在市场上常规的二、四相混合式步进电机基本步距角都是1.8°。
  
  2 M& f$ v/ W6 ?. ]; G0 Q/ k( i* t

1 s( m8 a0 R/ Y) J相关问题：

问题：有一步进电机参数，如下：
[电压 12VDC  
相数 4  
减速比 1/64  
步距角 1.8° /64
驱动方式 四相八拍 ]
6 E" c$ s+ O: w2 m3 t% e4 U# ?0 h 请问： 步距角1.8°/64 ，后面的 “/64”表示什么意思？此步进电机转一圈，要多少步？

% S& J% I2 C$ ]# z" k  D/ o1 |

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

---

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

9 Y7 S% I: p7 W7 `

L298N主要参数说明

• 控制信号供电：直流5V；
• 电机供电：直流3V~46V（建议使用36V以下）
• 最大工作电流：2.5A
• 额定功率：25W
• 控制信号输入电压范围：
  
  
  • 低电平：-0.3V <= Vin <= 1.5V
  • 高电平：2.3V <= Vin <= Vss
    
    
• 使能信号输入电压范围：
  
  ) R3 j' g; t; X6 y
  • 低电平：-0.3V <= Vin <= 1.5V（控制信号无效）
  • 高电平：2.3V <= Vin <= Vss（控制信号有效）
    
    
• L298N芯片的输入电压有两个:

  如果步进电机为5VDC供电，那么VSS和VS可以短接到一起；
  VSS和VS两个电源要共地；
  L298N使用的过程中，发热较大，最好添加散热片。

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

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

; v/ a" t6 f) T# N4 ?

L298N原理图

5 o* O1 B; s2 N5 }& a. ]应用实例

驱动步进电机

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

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

- M) j. K* Z6 m5 ~: l/ e$ T

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

1. 
   1 @: @* I, K# s" e5 }3 g! K
2. void StepMotor_Init(void)
   ( X; G* H6 X* j9 o  s9 S' m9 c+ |
3. {
   / m! `( v( ~$ ^6 @$ s
4.         GPIO_InitTypeDef  GPIO_InitStructure;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);       //使能PB,PC端口时钟
   ; j2 \  I- R+ f0 U$ |9 w9 W
6.         
   0 ^: C: B' z5 [( \
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
   
8.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   3 d9 C, S/ p' j8 M8 t* x
9.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   ' b' V4 c) t" B' r8 q
10.         GPIO_Init(GPIOC, &GPIO_InitStructure);
    
11.         GPIO_SetBits(GPIOC,GPIO_Pin_6);
    + y2 Y% a/ P- W4 |3 Z
12.         GPIO_SetBits(GPIOC,GPIO_Pin_7);
    % P  C. m$ y* e+ `
13.         
    
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;
    ; i: j( i4 I, T, x
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
17.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
18. 
    
19.         L298D_1AA = 0;
    
20.         L298D_2AA = 0;
    
21.         L298D_3AA = 0;
    
22.         L298D_4AA = 0;
    3 B8 d" H9 c" R, G2 [
23.         L298D_12ENA = 0;
    2 U$ a- V, b# |# ]
24.         L298D_34ENA = 0;
    % J, W% L% d% i
25. }

复制代码

9 v: [( W. q& W6 o9 }! Z2. 两相电机驱动代码，包括正转和反转

1. 
   
2. void TwoPhaseMotor(unsigned char nInputData ,unsigned char nDirection)
   8 \5 N3 v# z' m8 d" A
3. {
   7 `/ \2 Z) H  K6 G$ y
4.         if(1 == nDirection)             //逆时针
   
5.         {
   + C# N7 Y) v" F3 P" `9 q4 ]
6.                 switch(nInputData)
   
7.                 {
   
8.                         case 1:
   + I1 Z2 ~! x0 v8 }
9.                         {
   
10.                                 L298D_1AA = 0;
    
11.                                 L298D_2AA = 1;
    
12.                                 L298D_3AA = 0;
    
13.                                 L298D_4AA = 1;
    4 X% }! z4 d- X  k
14.                         }
    / |% G4 D, O9 O
15.                         break;
    3 p/ v) J& K, w- p
16.                         case 2:
    ) Z# m, U  @# ?. {5 c9 i
17.                         {
    
18.                                 L298D_1AA = 0;
    ; h, M! }) S; x6 ~- p; x
19.                                 L298D_2AA = 1;
    
20.                                 L298D_3AA = 1;
    , F2 O) w1 p$ h' f* ~+ Q
21.                                 L298D_4AA = 0;
    
22.                         }
    % K# F& `1 N$ ?
23.                         break;
    & B3 G) Y- Q* k, k. |, u
24.                         case 3:
    
25.                         {
    % y' Q0 `& r4 H% D# t+ _
26.                                 L298D_1AA = 1;
    & ^7 g, S9 @: V9 Q' [
27.                                 L298D_2AA = 0;
    
28.                                 L298D_3AA = 1;
    # I6 o. D8 Z3 x- A
29.                                 L298D_4AA = 0;
    . b( V- S* y  s4 q6 u
30.                         }
    
31.                         break;
    
32.                         case 4:
    
33.                         {
    
34.                                 L298D_1AA = 1;
    2 @4 n7 b! n3 p
35.                                 L298D_2AA = 0;
    , I$ c0 O  C& m+ D+ e# m
36.                                 L298D_3AA = 0;
      k/ \( l$ K) m& ^
37.                                 L298D_4AA = 1;
    0 ], ^6 ?8 `* i8 l0 l5 F
38.                         }
    
39.                         break;
    
40.                 }
    
41.         }
    $ [, k% Y, I$ |" Q6 g
42.         else if(0 == nDirection)        //顺时针
    
43.         {
    
44.                 switch(nInputData)
    9 ]$ y2 d! Y% R( [
45.                 {
    , S1 m0 x  }4 C$ x. b5 A
46.                         case 1:
    + |% `: s9 J# {  t. |: H* I/ h
47.                         {
    
48.                                 L298D_1AA = 1;
    
49.                                 L298D_2AA = 0;
    
50.                                 L298D_3AA = 0;
    
51.                                 L298D_4AA = 1;
    
52.                         }
    
53.                         break;
    ! E6 D9 ^) j4 b0 Y! w( G
54.                         case 2:
    1 K# [: U5 U9 i" a: R6 _
55.                         {
    
56.                                 L298D_1AA = 1;
    9 }: T0 u; J6 @* b
57.                                 L298D_2AA = 0;
    9 x$ q/ W+ L/ M/ M3 _! s; R
58.                                 L298D_3AA = 1;
    
59.                                 L298D_4AA = 0;
    , {  ^9 Y3 |0 j7 F
60.                         }
    
61.                         break;
    & g7 e; N5 h/ k; J5 ~! C* Y- b) J
62.                         case 3:
    1 F! q5 s& n" f* d3 A4 ^% ]4 H
63.                         {
    
64.                                 L298D_1AA = 0;
    
65.                                 L298D_2AA = 1;
    5 S0 l$ I+ {$ G4 V, }; n+ E0 V& }
66.                                 L298D_3AA = 1;
    * x4 O: Q( R: Y( P
67.                                 L298D_4AA = 0;
    
68.                         }
    5 x  E' W: m( h% e+ A% @
69.                         break;
    
70.                         case 4:
    
71.                         {
    % q8 b6 h. i2 C
72.                                 L298D_1AA = 0;
    
73.                                 L298D_2AA = 1;
    
74.                                 L298D_3AA = 0;
    
75.                                 L298D_4AA = 1;
    + ]4 m- D5 J, C- T
76.                         }
    , G1 S6 p* V5 J; P3 l# ^0 t+ \! O
77.                         break;
    1 M& L$ e! L" N+ b) [; R, e
78.                 }
    ; C: j; J8 }) d! y
79.         }
    " W/ H  s  f8 X
80. }

复制代码

9 K  i8 H1 Q( u5 q( s% m7 ?# }6 A

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

1. 
   & P/ I# U8 v3 t! f2 B( q
2. void TwoPhaseMotorNCircle(int n,unsigned char direction)
   
3. {
   3 u3 `0 Z7 v" r4 Z, b  w+ x
4.     int i,j;
   2 C& Z. B2 C" J8 T& W) K7 ~2 [
5.         
   
6.     L298D_12ENA = 1;    //只有转的时候使能，否则持续供电，芯片和电机过热。
   
7.     L298D_34ENA = 1;
   
8.    
   
9.     for(i=0;i<n;i++)
   ( b9 r, q3 H1 t, B1 a% f+ o9 r' g
10.     {
    ) [# ]! ^5 \2 k! Q
11.         for(j=1;j<=4;j++)
    
12.         {
    ' d1 x% D, ^& c. M. o: ?$ X8 n  d
13.             TwoPhaseMotor(j,direction);
    * j' v0 q' A+ c( K4 v/ b( o6 g1 c
14.             delay_ms(2);
    * S: _' P' j9 e0 w6 z% j0 _/ ?1 I: a$ \* y
15.         }
    % Y" f& t  {! k2 R( A) m
16.     }
    
17.    
    # \: A; R. A* L0 F, l/ K, Q
18.     L298D_12ENA = 0;
    
19.     L298D_34ENA = 0;
    
20. }

复制代码

3. 主函数中调用说明：

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

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

主函数代码如下：
( s& }* o4 R6 V% ]. ]" O6 Q

1. 
   
2. int main(void)
   / E+ D' j. _* C) ?  n2 y: L
3. {
   
4.         //解析payload数据包使用
   
5.         cJSON *receive_json, *item_obj;
   
6.          
   
7.         u16 i;
   
8.         u16 uart2Len=0;
   3 Q  ]' ]4 ?8 t  _2 l
9.          
   . J% K9 H, u7 o. x
10.         u8 dtbuf[50];   //打印缓存器
    8 w' G) L- e/ N1 i
11.                  
    
12.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
13. 
    
14.         USART2_RX_STA=0;
    ) y& v7 P! E. ?$ z4 {1 Q
15.         memset(USART2_RX_BUF, 0, sizeof(USART2_RX_BUF));
    
16.         
    ! U( N1 t, H$ B' M$ p
17.         memset(dtbuf,'\0',50);
    
18. 
    
19.         //初始化
    / t( j( _# |( u
20.         //延时函数初始化
    
21.         delay_init();
    : ~4 s/ ]# s5 U4 R  s9 v
22.                   
    2 w" Q9 W" w8 \
23.         uart_init(115200);                      //串口1:Debug,初始化为115200
    ! g  y* [/ v0 M: m, ]6 {: _- h
24.         uart2_init(115200);
    ) e  d0 a& c/ X# s2 Z8 ?/ R
25.         
    ( H/ ?( x# _* z% Y& O
26.         //定时器3,--步进电机使用
    8 Q: q6 S- k& z1 s+ b
27.         TIM3_Int_Init(99,7199);         //1ms中断
    & ^! Y' z9 X7 o. {9 ~
28.         TIM3_Set(0);
    
29. 
    ) ]$ x) \+ {8 P* l! T
30.         StepMotor_Init();
    $ H$ @: v0 M& U8 Y8 Y
31.         
    
32.         printf("System Init OK \r\n");
    ! n% [5 i8 D" o. S% U
33.         
    
34.         //主循环
    
35.         while(1)
    4 j% p' H8 s5 B/ f: J
36.         {
    . Z1 o5 j; o, C$ j/ j3 r; U
37.                 //ESP8266
    
38.                 if(USART2_RX_STA&0x8000)
    
39.                 {
    5 m; x) W, h7 M3 ^+ \
40.                         uart2Len=USART2_RX_STA&0x3f;
    , Q' F6 [* P. N9 e
41.                     
    
42.                         receive_json = cJSON_Parse(USART2_RX_BUF);      //创建JSON解析对象，返回JSON格式是否正确
    
43.                         if (!receive_json)
    
44.                         {
    
45.                                 printf("JSON格式错误:%s\r\n", cJSON_GetErrorPtr()); //输出json格式错误信息
    # p0 v! P3 K: }
46.                         }
    1 N2 h! o: M9 ]1 E+ z2 H3 ~
47.                         else
    ! |+ e# R1 m0 m
48.                         {
    
49.                                 printf("JSON格式正确:\n%s\r\n",cJSON_Print(receive_json) );
    
50.                                 item_obj = receive_json->child; //获取name键对应的值的信息
    
51.                                 
    
52.                                 while(item_obj)
    
53.                                 {
      F) v% a1 N" r, z! u% B5 T
54.                                         char * string = item_obj->string;
    3 {) G7 o* ~5 n
55.                                        
    : z' h1 Z/ `  y7 }& B
56.                                         if(!strcmp(string,"PowerSwitch"))
    * v8 H2 S" w: Z% O& I
57.                                         {
    
58.                                                 if(item_obj->valueint==1)
    ' {) S3 q& T, G& B' T) O; E
59.                                                 {
    % Q& @3 N6 ?* `  f
60.                                                         L298D_12ENA = 1;        //只有转的时候使能，否则持续供电，芯片和电机过热。
    
61.                                                         L298D_34ENA = 1;
    - \% x1 r* e4 P# K# y
62.                                                         
    ( o2 ?+ u7 `8 H! P' K
63.                                                         TIM3_Set(1);
    8 h5 H* U' G; \. S
64.                                                         
    
65.                                                         nRotationCounting = 0;
    & j! ~- m) ~8 S; a( b
66.                                                         
    
67.                                                         stuAliOSIoT.PowerSwitch = 1;
    - O' {/ P" p" I' X9 \$ s
68.                                                         
    
69.                                                         printf("PowerSwitch:1\r\n");
    " p8 q" m# p1 H
70.                                                 }
    
71.                                                 else if(item_obj->valueint==0)
    . D% H* s; Q1 }! D
72.                                                 {
    
73.                                                         //步进电机运动停止
    
74.                                                         L298D_12ENA = 0;
    
75.                                                         L298D_34ENA = 0;
    
76.                                                         
    ; d) j* h7 E* V
77.                                                         TIM3_Set(0);
    + H* W6 \/ }$ v& u9 n
78.                                                         
    % N; t" E* v( z. }' Y3 ~/ q/ M
79.                                                         stuAliOSIoT.PowerSwitch = 0;
    0 f4 Q  r% k, V! N1 r
80.                                                         
    
81.                                                         printf("PowerSwitch:0\r\n");
    + {$ k  [6 D( s( t- B: ^
82.                                                 }
    
83.                                         }
    $ [4 E+ u( p+ L" Z* w
84.                                        
    
85.                                         item_obj = item_obj->next;
    
86.                                 }
    
87.                                 
    * |, A. W+ O; f
88.                                 cJSON_Delete(receive_json);
    $ m& i/ i, T5 W3 H. [, T
89.                                 
    9 e, n3 f! |9 t$ B8 m/ O7 c* u
90.                         }
    
91.                         
    5 v" ]/ d! c) i
92.                         USART2_RX_STA=0;
    
93.                         memset(USART2_RX_BUF, 0, sizeof(USART2_RX_BUF));   //清空数组
    
94.                 }
    
95.                                 
    
96.                 delay_ms(10);
    * P3 H7 g1 T! T  O
97.         }
    . X2 U: A8 W$ ~5 d2 h7 @
98.         
    8 h6 s2 @: S* e. v! H" B$ F! j3 ]; G
99. }

复制代码

1 D: n  J8 u3 `2 Q

定时器中代码如下：

1. 
   
2. //定时器3中断服务程序
   & e; G0 s0 l( ^9 D8 J5 P1 u- b8 Q
3. void TIM3_IRQHandler(void)
   
4. {
   
5.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//是更新中断
   
6.         {
   
7.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIM3更新中断标志
   7 ~  v% x: F0 ~
8.                
   ! c$ {8 J9 ?9 W$ T
9.                 nRotationCounting++;
   
10.                 if(nRotationCounting > nSingleCycleDataPoints)
    ; b$ A% e( Q( j7 Y
11.                 {
    
12.                         if(nRotationDirection==0)
    / u9 h5 A$ N! n) U" k
13.                         {
    
14.                                 nRotationDirection=1;
    
15.                         }
    
16.                         else if(nRotationDirection==1)
    
17.                         {
    2 P' ~) s+ I  h3 z, Z) T' n, y' ^
18.                                 nRotationDirection=0;
    
19.                         }
    
20.                         
    
21.                         nRotationCounting=0;
    1 b& q/ G5 a( ]% P( ?
22.                 }
    
23.                
    
24.                 if(stuAliOSIoT.PowerSwitch)
    : D- W+ {4 v: D" S+ p3 T" O
25.                 {
    
26.                         if(nRotationDirection==0)                       //正转
    9 q5 E8 Z2 j% G# K8 n' u
27.                         {
    
28.                                 TwoPhaseMotor(nRotationCounting%4+1,0);                         //顺时针
    
29.                         }
    
30.                         else if(nRotationDirection==1)          //反转
    5 O& Z# X* y$ D; R9 k$ q
31.                         {
    
32.                                 TwoPhaseMotor(nRotationCounting%4+1,1);
    
33.                         }
    8 g0 P- i/ Q# P3 T; R
34.                 }
    
35.                
    3 ~3 E3 C3 C  n/ s4 F1 U
36.                 //TIM_Cmd(TIM3, DISABLE);  //关闭TIM3
    
37.         }
    
38. }

复制代码

: j" }, `6 t& F! a* q
+ q8 |6 ?# U7 c8 G% X/ L实物图

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

4 Q/ }3 l3 I7 g/ X6 t; K0 f% u2 `
6 v6 e$ d8 y) y